gailmisc.c
gail_private_h_sources = \
- gail.h \
gtkarrowaccessible.h \
gtkbooleancellaccessible.h \
gtkbuttonaccessible.h \
gtkcellaccessible.h \
gtkcellaccessibleparent.h \
gtkcheckmenuitemaccessible.h \
- gtkcolorswatchaccessible.h \
gtkcomboboxaccessible.h \
gtkcontaineraccessible.h \
gtkcontainercellaccessible.h \
gtktreeviewaccessible.h \
gtkwidgetaccessible.h \
gtkwindowaccessible.h \
+ gtkcolorswatchaccessible.h \
+ gtkcellaccessibleprivate.h \
+ gtklockbuttonaccessibleprivate.h \
+ gtkiconviewaccessibleprivate.h \
+ gtktreeviewaccessibleprivate.h \
+ gtktextviewaccessibleprivate.h \
+ gtkwidgetaccessibleprivate.h \
+ gail.h \
gailutil.h \
gailmisc.h
static void atk_image_interface_init (AtkImageIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkArrowAccessible, _gtk_arrow_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkArrowAccessible, gtk_arrow_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_IMAGE, atk_image_interface_init))
static void
gtk_arrow_accessible_initialize (AtkObject *accessible,
gpointer data)
{
- ATK_OBJECT_CLASS (_gtk_arrow_accessible_parent_class)->initialize (accessible, data);
+ ATK_OBJECT_CLASS (gtk_arrow_accessible_parent_class)->initialize (accessible, data);
accessible->role = ATK_ROLE_ICON;
}
g_free (arrow->priv->image_description);
- G_OBJECT_CLASS (_gtk_arrow_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gtk_arrow_accessible_parent_class)->finalize (object);
}
static void
-_gtk_arrow_accessible_class_init (GtkArrowAccessibleClass *klass)
+gtk_arrow_accessible_class_init (GtkArrowAccessibleClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
AtkObjectClass *atk_object_class = ATK_OBJECT_CLASS (klass);
}
static void
-_gtk_arrow_accessible_init (GtkArrowAccessible *arrow)
+gtk_arrow_accessible_init (GtkArrowAccessible *arrow)
{
arrow->priv = G_TYPE_INSTANCE_GET_PRIVATE (arrow,
GTK_TYPE_ARROW_ACCESSIBLE,
G_BEGIN_DECLS
-#define GTK_TYPE_ARROW_ACCESSIBLE (_gtk_arrow_accessible_get_type ())
+#define GTK_TYPE_ARROW_ACCESSIBLE (gtk_arrow_accessible_get_type ())
#define GTK_ARROW_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ARROW_ACCESSIBLE, GtkArrowAccessible))
#define GTK_ARROW_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ARROW_ACCESSIBLE, GtkArrowAccessibleClass))
#define GTK_IS_ARROW_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ARROW_ACCESSIBLE))
GtkWidgetAccessibleClass parent_class;
};
-GType _gtk_arrow_accessible_get_type (void);
+GType gtk_arrow_accessible_get_type (void);
G_END_DECLS
}
-G_DEFINE_TYPE_EXTENDED (GtkBooleanCellAccessible, _gtk_boolean_cell_accessible, GTK_TYPE_RENDERER_CELL_ACCESSIBLE, 0,
+G_DEFINE_TYPE_EXTENDED (GtkBooleanCellAccessible, gtk_boolean_cell_accessible, GTK_TYPE_RENDERER_CELL_ACCESSIBLE, 0,
G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION, gtk_boolean_cell_accessible_action_interface_init))
GtkBooleanCellAccessible *cell = GTK_BOOLEAN_CELL_ACCESSIBLE (accessible);
AtkStateSet *state_set;
- state_set = ATK_OBJECT_CLASS (_gtk_boolean_cell_accessible_parent_class)->ref_state_set (accessible);
+ state_set = ATK_OBJECT_CLASS (gtk_boolean_cell_accessible_parent_class)->ref_state_set (accessible);
if (cell->priv->cell_value)
atk_state_set_add_state (state_set, ATK_STATE_CHECKED);
}
static void
-_gtk_boolean_cell_accessible_class_init (GtkBooleanCellAccessibleClass *klass)
+gtk_boolean_cell_accessible_class_init (GtkBooleanCellAccessibleClass *klass)
{
GtkCellAccessibleClass *cell_class = GTK_CELL_ACCESSIBLE_CLASS (klass);
AtkObjectClass *atkobject_class = ATK_OBJECT_CLASS (klass);
}
static void
-_gtk_boolean_cell_accessible_init (GtkBooleanCellAccessible *cell)
+gtk_boolean_cell_accessible_init (GtkBooleanCellAccessible *cell)
{
cell->priv = G_TYPE_INSTANCE_GET_PRIVATE (cell,
GTK_TYPE_BOOLEAN_CELL_ACCESSIBLE,
G_BEGIN_DECLS
-#define GTK_TYPE_BOOLEAN_CELL_ACCESSIBLE (_gtk_boolean_cell_accessible_get_type ())
+#define GTK_TYPE_BOOLEAN_CELL_ACCESSIBLE (gtk_boolean_cell_accessible_get_type ())
#define GTK_BOOLEAN_CELL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_BOOLEAN_CELL_ACCESSIBLE, GtkBooleanCellAccessible))
#define GTK_BOOLEAN_CELL_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GAIL_BOOLEAN_CELL, GtkBooleanCellAccessibleClass))
#define GTK_IS_BOOLEAN_CELL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_BOOLEAN_CELL_ACCESSIBLE))
GtkRendererCellAccessibleClass parent_class;
};
-GType _gtk_boolean_cell_accessible_get_type (void);
+GType gtk_boolean_cell_accessible_get_type (void);
G_END_DECLS
static void atk_action_interface_init (AtkActionIface *iface);
static void atk_image_interface_init (AtkImageIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkButtonAccessible, _gtk_button_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkButtonAccessible, gtk_button_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION, atk_action_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_IMAGE, atk_image_interface_init))
{
GtkWidget *parent;
- ATK_OBJECT_CLASS (_gtk_button_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (gtk_button_accessible_parent_class)->initialize (obj, data);
g_signal_connect (data, "state-flags-changed", G_CALLBACK (state_changed_cb), NULL);
if (widget == NULL)
return NULL;
- name = ATK_OBJECT_CLASS (_gtk_button_accessible_parent_class)->get_name (obj);
+ name = ATK_OBJECT_CLASS (gtk_button_accessible_parent_class)->get_name (obj);
if (name != NULL)
return name;
if (widget == NULL)
return NULL;
- state_set = ATK_OBJECT_CLASS (_gtk_button_accessible_parent_class)->ref_state_set (obj);
+ state_set = ATK_OBJECT_CLASS (gtk_button_accessible_parent_class)->ref_state_set (obj);
if ((gtk_widget_get_state_flags (widget) & GTK_STATE_FLAG_ACTIVE) != 0)
atk_state_set_add_state (state_set, ATK_STATE_ARMED);
g_signal_emit_by_name (atk_obj, "visible-data-changed");
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_button_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (gtk_button_accessible_parent_class)->notify_gtk (obj, pspec);
}
static void
-_gtk_button_accessible_class_init (GtkButtonAccessibleClass *klass)
+gtk_button_accessible_class_init (GtkButtonAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
GtkContainerAccessibleClass *container_class = (GtkContainerAccessibleClass*)klass;
}
static void
-_gtk_button_accessible_init (GtkButtonAccessible *button)
+gtk_button_accessible_init (GtkButtonAccessible *button)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_BUTTON_ACCESSIBLE (_gtk_button_accessible_get_type ())
+#define GTK_TYPE_BUTTON_ACCESSIBLE (gtk_button_accessible_get_type ())
#define GTK_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_BUTTON_ACCESSIBLE, GtkButtonAccessible))
#define GTK_BUTTON_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_BUTTON_ACCESSIBLE, GtkButtonAccessibleClass))
#define GTK_IS_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_BUTTON_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType _gtk_button_accessible_get_type (void);
+GType gtk_button_accessible_get_type (void);
G_END_DECLS
#include <gtk/gtk.h>
#include "gtkcontainercellaccessible.h"
-#include "gtkcellaccessible.h"
+#include "gtkcellaccessibleprivate.h"
#include "gtkcellaccessibleparent.h"
static const struct {
{ ATK_STATE_EXPANDED, GTK_CELL_RENDERER_EXPANDED, FALSE },
};
+static GtkCellRendererState gtk_cell_accessible_get_state (GtkCellAccessible *cell);
static void atk_action_interface_init (AtkActionIface *iface);
static void atk_component_interface_init (AtkComponentIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkCellAccessible, _gtk_cell_accessible, GTK_TYPE_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkCellAccessible, gtk_cell_accessible, GTK_TYPE_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION, atk_action_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_COMPONENT, atk_component_interface_init))
}
g_object_unref (relation_set);
}
- G_OBJECT_CLASS (_gtk_cell_accessible_parent_class)->finalize (obj);
+ G_OBJECT_CLASS (gtk_cell_accessible_parent_class)->finalize (obj);
}
static gint
parent = atk_object_get_parent (obj);
if (GTK_IS_CONTAINER_CELL_ACCESSIBLE (parent))
- return g_list_index (_gtk_container_cell_accessible_get_children (GTK_CONTAINER_CELL_ACCESSIBLE (parent)), obj);
+ return g_list_index (gtk_container_cell_accessible_get_children (GTK_CONTAINER_CELL_ACCESSIBLE (parent)), obj);
parent = gtk_widget_get_accessible (gtk_accessible_get_widget (GTK_ACCESSIBLE (cell)));
if (parent == NULL)
return -1;
- return _gtk_cell_accessible_parent_get_child_index (GTK_CELL_ACCESSIBLE_PARENT (parent), cell);
+ return gtk_cell_accessible_parent_get_child_index (GTK_CELL_ACCESSIBLE_PARENT (parent), cell);
}
static AtkStateSet *
return state_set;
}
- flags = _gtk_cell_accessible_get_state (cell_accessible);
+ flags = gtk_cell_accessible_get_state (cell_accessible);
atk_state_set_add_state (state_set, ATK_STATE_FOCUSABLE);
atk_state_set_add_state (state_set, ATK_STATE_SELECTABLE);
static void
-_gtk_cell_accessible_class_init (GtkCellAccessibleClass *klass)
+gtk_cell_accessible_class_init (GtkCellAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
GObjectClass *g_object_class = G_OBJECT_CLASS (klass);
}
static void
-_gtk_cell_accessible_init (GtkCellAccessible *cell)
+gtk_cell_accessible_init (GtkCellAccessible *cell)
{
}
void
-_gtk_cell_accessible_initialise (GtkCellAccessible *cell,
+_gtk_cell_accessible_initialize (GtkCellAccessible *cell,
GtkWidget *widget,
AtkObject *parent)
{
switch (index)
{
case 0:
- _gtk_cell_accessible_parent_expand_collapse (parent, cell);
+ gtk_cell_accessible_parent_expand_collapse (parent, cell);
break;
case 1:
- _gtk_cell_accessible_parent_edit (parent, cell);
+ gtk_cell_accessible_parent_edit (parent, cell);
break;
case 2:
- _gtk_cell_accessible_parent_activate (parent, cell);
+ gtk_cell_accessible_parent_activate (parent, cell);
break;
default:
return FALSE;
cell = GTK_CELL_ACCESSIBLE (component);
parent = gtk_widget_get_accessible (gtk_accessible_get_widget (GTK_ACCESSIBLE (cell)));
- _gtk_cell_accessible_parent_get_cell_extents (GTK_CELL_ACCESSIBLE_PARENT (parent),
+ gtk_cell_accessible_parent_get_cell_extents (GTK_CELL_ACCESSIBLE_PARENT (parent),
cell,
x, y, width, height, coord_type);
}
cell = GTK_CELL_ACCESSIBLE (component);
parent = gtk_widget_get_accessible (gtk_accessible_get_widget (GTK_ACCESSIBLE (cell)));
- return _gtk_cell_accessible_parent_grab_focus (GTK_CELL_ACCESSIBLE_PARENT (parent), cell);
+ return gtk_cell_accessible_parent_grab_focus (GTK_CELL_ACCESSIBLE_PARENT (parent), cell);
}
static void
iface->grab_focus = gtk_cell_accessible_grab_focus;
}
-/**
- * _gtk_cell_accessible_get_state:
- * @cell: a #GtkCellAccessible
- *
- * Gets the state that would be used to render the area referenced by @cell.
- *
- * Returns: the #GtkCellRendererState for cell
- **/
-GtkCellRendererState
-_gtk_cell_accessible_get_state (GtkCellAccessible *cell)
+static GtkCellRendererState
+gtk_cell_accessible_get_state (GtkCellAccessible *cell)
{
AtkObject *parent;
if (parent == NULL)
return 0;
- return _gtk_cell_accessible_parent_get_renderer_state (GTK_CELL_ACCESSIBLE_PARENT (parent), cell);
+ return gtk_cell_accessible_parent_get_renderer_state (GTK_CELL_ACCESSIBLE_PARENT (parent), cell);
}
-/**
- * _gtk_cell_accessible_state_changed:
+/*
+ * gtk_cell_accessible_state_changed:
* @cell: a #GtkCellAccessible
* @added: the flags that were added from @cell
* @removed: the flags that were removed from @cell
for (i = 0; i < G_N_ELEMENTS (state_map); i++)
{
if (added & state_map[i].renderer_state)
- atk_object_notify_state_change (object,
+ atk_object_notify_state_change (object,
state_map[i].atk_state,
!state_map[i].invert);
if (added & state_map[i].renderer_state)
- atk_object_notify_state_change (object,
+ atk_object_notify_state_change (object,
state_map[i].atk_state,
state_map[i].invert);
}
}
-/**
- * _gtk_cell_accessible_update_cache:
+/*
+ * gtk_cell_accessible_update_cache:
* @cell: the cell that is changed
*
* Notifies the cell that the values in the data in the row that
* cell_changed function of @cell is called to send update
* notifications for the properties it takes from its cell
* renderer.
- *
+ *
* Note that there is no higher granularity available about which
* properties changed, so you will need to make do with this
* function.
_gtk_cell_accessible_update_cache (GtkCellAccessible *cell)
{
GtkCellAccessibleClass *klass;
-
+
g_return_if_fail (GTK_CELL_ACCESSIBLE (cell));
klass = GTK_CELL_ACCESSIBLE_GET_CLASS (cell);
if (klass->update_cache)
klass->update_cache (cell);
}
-
G_BEGIN_DECLS
-#define GTK_TYPE_CELL_ACCESSIBLE (_gtk_cell_accessible_get_type ())
+#define GTK_TYPE_CELL_ACCESSIBLE (gtk_cell_accessible_get_type ())
#define GTK_CELL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_ACCESSIBLE, GtkCellAccessible))
#define GTK_CELL_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_ACCESSIBLE, GtkCellAccessibleClass))
#define GTK_IS_CELL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_ACCESSIBLE))
void (*update_cache) (GtkCellAccessible *cell);
};
-GType _gtk_cell_accessible_get_type (void);
-
-GtkCellRendererState
- _gtk_cell_accessible_get_state (GtkCellAccessible *cell);
-void _gtk_cell_accessible_state_changed (GtkCellAccessible *cell,
- GtkCellRendererState added,
- GtkCellRendererState removed);
-void _gtk_cell_accessible_update_cache (GtkCellAccessible *cell);
-
-void _gtk_cell_accessible_initialise (GtkCellAccessible *cell,
- GtkWidget *widget,
- AtkObject *parent);
-gboolean _gtk_cell_accessible_add_state (GtkCellAccessible *cell,
- AtkStateType state_type,
- gboolean emit_signal);
-gboolean _gtk_cell_accessible_remove_state (GtkCellAccessible *cell,
- AtkStateType state_type,
- gboolean emit_signal);
+GType gtk_cell_accessible_get_type (void);
G_END_DECLS
#include "gtkcellaccessibleparent.h"
GType
-_gtk_cell_accessible_parent_get_type (void)
+gtk_cell_accessible_parent_get_type (void)
{
static volatile gsize g_define_type_id__volatile = 0;
}
void
-_gtk_cell_accessible_parent_get_cell_extents (GtkCellAccessibleParent *parent,
- GtkCellAccessible *cell,
- gint *x,
- gint *y,
- gint *width,
- gint *height,
- AtkCoordType coord_type)
+gtk_cell_accessible_parent_get_cell_extents (GtkCellAccessibleParent *parent,
+ GtkCellAccessible *cell,
+ gint *x,
+ gint *y,
+ gint *width,
+ gint *height,
+ AtkCoordType coord_type)
{
GtkCellAccessibleParentIface *iface;
}
void
-_gtk_cell_accessible_parent_get_cell_area (GtkCellAccessibleParent *parent,
- GtkCellAccessible *cell,
- GdkRectangle *cell_rect)
+gtk_cell_accessible_parent_get_cell_area (GtkCellAccessibleParent *parent,
+ GtkCellAccessible *cell,
+ GdkRectangle *cell_rect)
{
GtkCellAccessibleParentIface *iface;
}
gboolean
-_gtk_cell_accessible_parent_grab_focus (GtkCellAccessibleParent *parent,
- GtkCellAccessible *cell)
+gtk_cell_accessible_parent_grab_focus (GtkCellAccessibleParent *parent,
+ GtkCellAccessible *cell)
{
GtkCellAccessibleParentIface *iface;
}
int
-_gtk_cell_accessible_parent_get_child_index (GtkCellAccessibleParent *parent,
- GtkCellAccessible *cell)
+gtk_cell_accessible_parent_get_child_index (GtkCellAccessibleParent *parent,
+ GtkCellAccessible *cell)
{
GtkCellAccessibleParentIface *iface;
}
GtkCellRendererState
-_gtk_cell_accessible_parent_get_renderer_state (GtkCellAccessibleParent *parent,
- GtkCellAccessible *cell)
+gtk_cell_accessible_parent_get_renderer_state (GtkCellAccessibleParent *parent,
+ GtkCellAccessible *cell)
{
GtkCellAccessibleParentIface *iface;
}
void
-_gtk_cell_accessible_parent_expand_collapse (GtkCellAccessibleParent *parent,
- GtkCellAccessible *cell)
+gtk_cell_accessible_parent_expand_collapse (GtkCellAccessibleParent *parent,
+ GtkCellAccessible *cell)
{
GtkCellAccessibleParentIface *iface;
}
void
-_gtk_cell_accessible_parent_activate (GtkCellAccessibleParent *parent,
- GtkCellAccessible *cell)
+gtk_cell_accessible_parent_activate (GtkCellAccessibleParent *parent,
+ GtkCellAccessible *cell)
{
GtkCellAccessibleParentIface *iface;
}
void
-_gtk_cell_accessible_parent_edit (GtkCellAccessibleParent *parent,
- GtkCellAccessible *cell)
+gtk_cell_accessible_parent_edit (GtkCellAccessibleParent *parent,
+ GtkCellAccessible *cell)
{
GtkCellAccessibleParentIface *iface;
* implement atk_component_get_extents().
*/
-#define GTK_TYPE_CELL_ACCESSIBLE_PARENT (_gtk_cell_accessible_parent_get_type ())
+#define GTK_TYPE_CELL_ACCESSIBLE_PARENT (gtk_cell_accessible_parent_get_type ())
#define GTK_IS_CELL_ACCESSIBLE_PARENT(obj) G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_ACCESSIBLE_PARENT)
#define GTK_CELL_ACCESSIBLE_PARENT(obj) G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_ACCESSIBLE_PARENT, GtkCellAccessibleParent)
#define GTK_CELL_ACCESSIBLE_PARENT_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GTK_TYPE_CELL_ACCESSIBLE_PARENT, GtkCellAccessibleParentIface))
GtkCellAccessible *cell);
};
-GType _gtk_cell_accessible_parent_get_type (void);
+GType gtk_cell_accessible_parent_get_type (void);
-void _gtk_cell_accessible_parent_get_cell_extents (GtkCellAccessibleParent *parent,
- GtkCellAccessible *cell,
- gint *x,
- gint *y,
- gint *width,
- gint *height,
- AtkCoordType coord_type);
-void _gtk_cell_accessible_parent_get_cell_area (GtkCellAccessibleParent *parent,
- GtkCellAccessible *cell,
- GdkRectangle *cell_rect);
-gboolean _gtk_cell_accessible_parent_grab_focus (GtkCellAccessibleParent *parent,
- GtkCellAccessible *cell);
-int _gtk_cell_accessible_parent_get_child_index (GtkCellAccessibleParent *parent,
- GtkCellAccessible *cell);
+void gtk_cell_accessible_parent_get_cell_extents (GtkCellAccessibleParent *parent,
+ GtkCellAccessible *cell,
+ gint *x,
+ gint *y,
+ gint *width,
+ gint *height,
+ AtkCoordType coord_type);
+void gtk_cell_accessible_parent_get_cell_area (GtkCellAccessibleParent *parent,
+ GtkCellAccessible *cell,
+ GdkRectangle *cell_rect);
+gboolean gtk_cell_accessible_parent_grab_focus (GtkCellAccessibleParent *parent,
+ GtkCellAccessible *cell);
+int gtk_cell_accessible_parent_get_child_index (GtkCellAccessibleParent *parent,
+ GtkCellAccessible *cell);
GtkCellRendererState
- _gtk_cell_accessible_parent_get_renderer_state(GtkCellAccessibleParent *parent,
- GtkCellAccessible *cell);
-void _gtk_cell_accessible_parent_expand_collapse (GtkCellAccessibleParent *parent,
- GtkCellAccessible *cell);
-void _gtk_cell_accessible_parent_activate (GtkCellAccessibleParent *parent,
- GtkCellAccessible *cell);
-void _gtk_cell_accessible_parent_edit (GtkCellAccessibleParent *parent,
+ gtk_cell_accessible_parent_get_renderer_state(GtkCellAccessibleParent *parent,
GtkCellAccessible *cell);
+void gtk_cell_accessible_parent_expand_collapse (GtkCellAccessibleParent *parent,
+ GtkCellAccessible *cell);
+void gtk_cell_accessible_parent_activate (GtkCellAccessibleParent *parent,
+ GtkCellAccessible *cell);
+void gtk_cell_accessible_parent_edit (GtkCellAccessibleParent *parent,
+ GtkCellAccessible *cell);
G_END_DECLS
--- /dev/null
+/* GAIL - The GNOME Accessibility Implementation Library
+ * Copyright 2001 Sun Microsystems Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __GTK_CELL_ACCESSIBLE_PRIVATE_H__
+#define __GTK_CELL_ACCESSIBLE_PRIVATE_H__
+
+#include "gtkcellaccessible.h"
+
+G_BEGIN_DECLS
+
+void _gtk_cell_accessible_state_changed (GtkCellAccessible *cell,
+ GtkCellRendererState added,
+ GtkCellRendererState removed);
+void _gtk_cell_accessible_update_cache (GtkCellAccessible *cell);
+void _gtk_cell_accessible_initialize (GtkCellAccessible *cell,
+ GtkWidget *widget,
+ AtkObject *parent);
+gboolean _gtk_cell_accessible_add_state (GtkCellAccessible *cell,
+ AtkStateType state_type,
+ gboolean emit_signal);
+gboolean _gtk_cell_accessible_remove_state (GtkCellAccessible *cell,
+ AtkStateType state_type,
+ gboolean emit_signal);
+
+G_END_DECLS
+
+#endif /* __GTK_CELL_ACCESSIBLE_PRIVATE_H__ */
#include "gtkcheckmenuitemaccessible.h"
-G_DEFINE_TYPE (GtkCheckMenuItemAccessible, _gtk_check_menu_item_accessible, GTK_TYPE_MENU_ITEM_ACCESSIBLE)
+G_DEFINE_TYPE (GtkCheckMenuItemAccessible, gtk_check_menu_item_accessible, GTK_TYPE_MENU_ITEM_ACCESSIBLE)
static void
toggled_cb (GtkWidget *widget)
gtk_check_menu_item_accessible_initialize (AtkObject *obj,
gpointer data)
{
- ATK_OBJECT_CLASS (_gtk_check_menu_item_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (gtk_check_menu_item_accessible_parent_class)->initialize (obj, data);
g_signal_connect (data, "toggled", G_CALLBACK (toggled_cb), NULL);
if (widget == NULL)
return NULL;
- state_set = ATK_OBJECT_CLASS (_gtk_check_menu_item_accessible_parent_class)->ref_state_set (accessible);
+ state_set = ATK_OBJECT_CLASS (gtk_check_menu_item_accessible_parent_class)->ref_state_set (accessible);
check_menu_item = GTK_CHECK_MENU_ITEM (widget);
static void
gtk_check_menu_item_accessible_notify_gtk (GObject *obj,
- GParamSpec *pspec)
+ GParamSpec *pspec)
{
GtkCheckMenuItem *check_menu_item = GTK_CHECK_MENU_ITEM (obj);
AtkObject *atk_obj;
atk_object_notify_state_change (atk_obj, ATK_STATE_ENABLED, (sensitive && !inconsistent));
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_check_menu_item_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (gtk_check_menu_item_accessible_parent_class)->notify_gtk (obj, pspec);
}
static void
-_gtk_check_menu_item_accessible_class_init (GtkCheckMenuItemAccessibleClass *klass)
+gtk_check_menu_item_accessible_class_init (GtkCheckMenuItemAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
}
static void
-_gtk_check_menu_item_accessible_init (GtkCheckMenuItemAccessible *item)
+gtk_check_menu_item_accessible_init (GtkCheckMenuItemAccessible *item)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_CHECK_MENU_ITEM_ACCESSIBLE (_gtk_check_menu_item_accessible_get_type ())
+#define GTK_TYPE_CHECK_MENU_ITEM_ACCESSIBLE (gtk_check_menu_item_accessible_get_type ())
#define GTK_CHECK_MENU_ITEM_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CHECK_MENU_ITEM_ACCESSIBLE, GtkCheckMenuItemAccessible))
#define GTK_CHECK_MENU_ITEM_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CHECK_MENU_ITEM_ACCESSIBLE, GtkCheckMenuItemAccessibleClass))
#define GTK_IS_CHECK_MENU_ITEM_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CHECK_MENU_ITEM_ACCESSIBLE))
GtkMenuItemAccessibleClass parent_class;
};
-GType _gtk_check_menu_item_accessible_get_type (void);
+GType gtk_check_menu_item_accessible_get_type (void);
G_END_DECLS
static void atk_action_interface_init (AtkActionIface *iface);
static void atk_selection_interface_init (AtkSelectionIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkComboBoxAccessible, _gtk_combo_box_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkComboBoxAccessible, gtk_combo_box_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION, atk_action_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_SELECTION, atk_selection_interface_init))
GtkComboBoxAccessible *accessible;
AtkObject *popup;
- ATK_OBJECT_CLASS (_gtk_combo_box_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (gtk_combo_box_accessible_parent_class)->initialize (obj, data);
combo_box = GTK_COMBO_BOX (data);
accessible = GTK_COMBO_BOX_ACCESSIBLE (obj);
g_free (combo_box->priv->name);
- G_OBJECT_CLASS (_gtk_combo_box_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gtk_combo_box_accessible_parent_class)->finalize (object);
}
static const gchar *
gint n_columns;
gint i;
- name = ATK_OBJECT_CLASS (_gtk_combo_box_accessible_parent_class)->get_name (obj);
+ name = ATK_OBJECT_CLASS (gtk_combo_box_accessible_parent_class)->get_name (obj);
if (name)
return name;
}
static void
-_gtk_combo_box_accessible_class_init (GtkComboBoxAccessibleClass *klass)
+gtk_combo_box_accessible_class_init (GtkComboBoxAccessibleClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-_gtk_combo_box_accessible_init (GtkComboBoxAccessible *combo_box)
+gtk_combo_box_accessible_init (GtkComboBoxAccessible *combo_box)
{
combo_box->priv = G_TYPE_INSTANCE_GET_PRIVATE (combo_box,
GTK_TYPE_COMBO_BOX_ACCESSIBLE,
G_BEGIN_DECLS
-#define GTK_TYPE_COMBO_BOX_ACCESSIBLE (_gtk_combo_box_accessible_get_type ())
+#define GTK_TYPE_COMBO_BOX_ACCESSIBLE (gtk_combo_box_accessible_get_type ())
#define GTK_COMBO_BOX_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_COMBO_BOX_ACCESSIBLE, GtkComboBoxAccessible))
#define GTK_COMBO_BOX_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_COMBO_BOX_ACCESSIBLE, GtkComboBoxAccessibleClass))
#define GTK_IS_COMBO_BOX_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_COMBO_BOX_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType _gtk_combo_box_accessible_get_type (void);
+GType gtk_combo_box_accessible_get_type (void);
G_END_DECLS
GList *children;
};
-G_DEFINE_TYPE (GtkContainerAccessible, _gtk_container_accessible, GTK_TYPE_WIDGET_ACCESSIBLE)
+G_DEFINE_TYPE (GtkContainerAccessible, gtk_container_accessible, GTK_TYPE_WIDGET_ACCESSIBLE)
static gint
gtk_container_accessible_get_n_children (AtkObject* obj)
{
GtkContainerAccessible *accessible = GTK_CONTAINER_ACCESSIBLE (obj);
- ATK_OBJECT_CLASS (_gtk_container_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (gtk_container_accessible_parent_class)->initialize (obj, data);
accessible->priv->children = gtk_container_get_children (GTK_CONTAINER (data));
g_list_free (accessible->priv->children);
- G_OBJECT_CLASS (_gtk_container_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gtk_container_accessible_parent_class)->finalize (object);
}
static void
-_gtk_container_accessible_class_init (GtkContainerAccessibleClass *klass)
+gtk_container_accessible_class_init (GtkContainerAccessibleClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-_gtk_container_accessible_init (GtkContainerAccessible *container)
+gtk_container_accessible_init (GtkContainerAccessible *container)
{
container->priv = G_TYPE_INSTANCE_GET_PRIVATE (container,
GTK_TYPE_CONTAINER_ACCESSIBLE,
G_BEGIN_DECLS
-#define GTK_TYPE_CONTAINER_ACCESSIBLE (_gtk_container_accessible_get_type ())
+#define GTK_TYPE_CONTAINER_ACCESSIBLE (gtk_container_accessible_get_type ())
#define GTK_CONTAINER_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CONTAINER_ACCESSIBLE, GtkContainerAccessible))
#define GTK_CONTAINER_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CONTAINER_ACCESSIBLE, GtkContainerAccessibleClass))
#define GTK_IS_CONTAINER_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CONTAINER_ACCESSIBLE))
gpointer data);
};
-GType _gtk_container_accessible_get_type (void);
+GType gtk_container_accessible_get_type (void);
G_END_DECLS
#include <gtk/gtk.h>
#include "gtkcontainercellaccessible.h"
+#include "gtkcellaccessibleprivate.h"
struct _GtkContainerCellAccessiblePrivate
{
gint n_children;
};
-G_DEFINE_TYPE (GtkContainerCellAccessible, _gtk_container_cell_accessible, GTK_TYPE_CELL_ACCESSIBLE)
+G_DEFINE_TYPE (GtkContainerCellAccessible, gtk_container_cell_accessible, GTK_TYPE_CELL_ACCESSIBLE)
static void
g_list_free_full (container->priv->children, g_object_unref);
- G_OBJECT_CLASS (_gtk_container_cell_accessible_parent_class)->finalize (obj);
+ G_OBJECT_CLASS (gtk_container_cell_accessible_parent_class)->finalize (obj);
}
GList *l;
for (l = container->priv->children; l; l = l->next)
- {
- _gtk_cell_accessible_update_cache (l->data);
- }
+ _gtk_cell_accessible_update_cache (l->data);
}
static void
GList *l;
for (l = container->priv->children; l; l = l->next)
- {
- gtk_accessible_set_widget (l->data, gtk_accessible_get_widget (accessible));
- }
+ gtk_accessible_set_widget (l->data, gtk_accessible_get_widget (accessible));
- GTK_ACCESSIBLE_CLASS (_gtk_container_cell_accessible_parent_class)->widget_unset (accessible);
+ GTK_ACCESSIBLE_CLASS (gtk_container_cell_accessible_parent_class)->widget_unset (accessible);
}
static void
GList *l;
for (l = container->priv->children; l; l = l->next)
- {
- gtk_accessible_set_widget (l->data, NULL);
- }
+ gtk_accessible_set_widget (l->data, NULL);
- GTK_ACCESSIBLE_CLASS (_gtk_container_cell_accessible_parent_class)->widget_unset (accessible);
+ GTK_ACCESSIBLE_CLASS (gtk_container_cell_accessible_parent_class)->widget_unset (accessible);
}
static void
-_gtk_container_cell_accessible_class_init (GtkContainerCellAccessibleClass *klass)
+gtk_container_cell_accessible_class_init (GtkContainerCellAccessibleClass *klass)
{
GtkCellAccessibleClass *cell_class = GTK_CELL_ACCESSIBLE_CLASS (klass);
GtkAccessibleClass *accessible_class = GTK_ACCESSIBLE_CLASS (klass);
}
static void
-_gtk_container_cell_accessible_init (GtkContainerCellAccessible *cell)
+gtk_container_cell_accessible_init (GtkContainerCellAccessible *cell)
{
cell->priv = G_TYPE_INSTANCE_GET_PRIVATE (cell,
GTK_TYPE_CONTAINER_CELL_ACCESSIBLE,
}
GtkContainerCellAccessible *
-_gtk_container_cell_accessible_new (void)
+gtk_container_cell_accessible_new (void)
{
GObject *object;
}
void
-_gtk_container_cell_accessible_add_child (GtkContainerCellAccessible *container,
+gtk_container_cell_accessible_add_child (GtkContainerCellAccessible *container,
GtkCellAccessible *child)
{
g_return_if_fail (GTK_IS_CONTAINER_CELL_ACCESSIBLE (container));
}
void
-_gtk_container_cell_accessible_remove_child (GtkContainerCellAccessible *container,
+gtk_container_cell_accessible_remove_child (GtkContainerCellAccessible *container,
GtkCellAccessible *child)
{
g_return_if_fail (GTK_IS_CONTAINER_CELL_ACCESSIBLE (container));
}
GList *
-_gtk_container_cell_accessible_get_children (GtkContainerCellAccessible *container)
+gtk_container_cell_accessible_get_children (GtkContainerCellAccessible *container)
{
g_return_val_if_fail (GTK_IS_CONTAINER_CELL_ACCESSIBLE (container), NULL);
G_BEGIN_DECLS
-#define GTK_TYPE_CONTAINER_CELL_ACCESSIBLE (_gtk_container_cell_accessible_get_type ())
+#define GTK_TYPE_CONTAINER_CELL_ACCESSIBLE (gtk_container_cell_accessible_get_type ())
#define GTK_CONTAINER_CELL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CONTAINER_CELL_ACCESSIBLE, GtkContainerCellAccessible))
#define GTK_CONTAINER_CELL_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CONTAINER_CELL_ACCESSIBLE, GtkContainerCellAccessibleClass))
#define GTK_IS_CONTAINER_CELL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CONTAINER_CELL_ACCESSIBLE))
GtkCellAccessibleClass parent_class;
};
-GType _gtk_container_cell_accessible_get_type (void);
+GType gtk_container_cell_accessible_get_type (void);
-GtkContainerCellAccessible *_gtk_container_cell_accessible_new (void);
-void _gtk_container_cell_accessible_add_child (GtkContainerCellAccessible *container,
- GtkCellAccessible *child);
-void _gtk_container_cell_accessible_remove_child (GtkContainerCellAccessible *container,
- GtkCellAccessible *child);
-GList *_gtk_container_cell_accessible_get_children (GtkContainerCellAccessible *container);
+GtkContainerCellAccessible *gtk_container_cell_accessible_new (void);
+void gtk_container_cell_accessible_add_child (GtkContainerCellAccessible *container,
+ GtkCellAccessible *child);
+void gtk_container_cell_accessible_remove_child (GtkContainerCellAccessible *container,
+ GtkCellAccessible *child);
+GList *gtk_container_cell_accessible_get_children (GtkContainerCellAccessible *container);
G_END_DECLS
#include "gtkentryprivate.h"
#include "gtkcomboboxaccessible.h"
-#define GTK_TYPE_ENTRY_ICON_ACCESSIBLE (_gtk_entry_icon_accessible_get_type ())
+#define GTK_TYPE_ENTRY_ICON_ACCESSIBLE (gtk_entry_icon_accessible_get_type ())
#define GTK_ENTRY_ICON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ENTRY_ICON_ACCESSIBLE, GtkEntryIconAccessible))
#define GTK_IS_ENTRY_ICON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ENTRY_ICON_ACCESSIBLE))
static void icon_atk_action_interface_init (AtkActionIface *iface);
static void icon_atk_component_interface_init (AtkComponentIface *iface);
-GType _gtk_entry_icon_accessible_get_type (void);
+GType gtk_entry_icon_accessible_get_type (void);
-G_DEFINE_TYPE_WITH_CODE (GtkEntryIconAccessible, _gtk_entry_icon_accessible, ATK_TYPE_OBJECT,
+G_DEFINE_TYPE_WITH_CODE (GtkEntryIconAccessible, gtk_entry_icon_accessible, ATK_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION, icon_atk_action_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_COMPONENT, icon_atk_component_interface_init))
GtkEntryIconAccessible *icon;
AtkObject *accessible;
- icon = g_object_new (_gtk_entry_icon_accessible_get_type (), NULL);
+ icon = g_object_new (gtk_entry_icon_accessible_get_type (), NULL);
icon->entry = entry;
g_object_weak_ref (G_OBJECT (entry),
gtk_entry_icon_accessible_remove_entry,
}
static void
-_gtk_entry_icon_accessible_init (GtkEntryIconAccessible *icon)
+gtk_entry_icon_accessible_init (GtkEntryIconAccessible *icon)
{
}
const gchar *name;
gchar *text;
- ATK_OBJECT_CLASS (_gtk_entry_icon_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (gtk_entry_icon_accessible_parent_class)->initialize (obj, data);
atk_object_set_role (obj, ATK_ROLE_ICON);
name = gtk_entry_get_icon_name (gtk_entry, icon->pos);
gtk_entry_icon_accessible_invalidate (icon);
- G_OBJECT_CLASS (_gtk_entry_icon_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gtk_entry_icon_accessible_parent_class)->finalize (object);
}
static void
-_gtk_entry_icon_accessible_class_init (GtkEntryIconAccessibleClass *klass)
+gtk_entry_icon_accessible_class_init (GtkEntryIconAccessibleClass *klass)
{
AtkObjectClass *atk_class = ATK_OBJECT_CLASS (klass);
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
static void atk_action_interface_init (AtkActionIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkEntryAccessible, _gtk_entry_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkEntryAccessible, gtk_entry_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_EDITABLE_TEXT, atk_editable_text_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_TEXT, atk_text_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION, atk_action_interface_init))
if (widget == NULL)
return NULL;
- state_set = ATK_OBJECT_CLASS (_gtk_entry_accessible_parent_class)->ref_state_set (accessible);
+ state_set = ATK_OBJECT_CLASS (gtk_entry_accessible_parent_class)->ref_state_set (accessible);
g_object_get (G_OBJECT (widget), "editable", &value, NULL);
if (value)
AtkAttribute *placeholder_text;
const gchar *text;
- attributes = ATK_OBJECT_CLASS (_gtk_entry_accessible_parent_class)->get_attributes (accessible);
+ attributes = ATK_OBJECT_CLASS (gtk_entry_accessible_parent_class)->get_attributes (accessible);
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
if (widget == NULL)
GtkEntryAccessible *gtk_entry_accessible;
gint start_pos, end_pos;
- ATK_OBJECT_CLASS (_gtk_entry_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (gtk_entry_accessible_parent_class)->initialize (obj, data);
gtk_entry_accessible = GTK_ENTRY_ACCESSIBLE (obj);
}
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_entry_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (gtk_entry_accessible_parent_class)->notify_gtk (obj, pspec);
}
static gint
if (GTK_IS_COMBO_BOX_ACCESSIBLE (accessible->accessible_parent))
return 1;
- return ATK_OBJECT_CLASS (_gtk_entry_accessible_parent_class)->get_index_in_parent (accessible);
+ return ATK_OBJECT_CLASS (gtk_entry_accessible_parent_class)->get_index_in_parent (accessible);
}
static gint
g_clear_object (&priv->icons[GTK_ENTRY_ICON_PRIMARY]);
g_clear_object (&priv->icons[GTK_ENTRY_ICON_SECONDARY]);
- G_OBJECT_CLASS (_gtk_entry_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gtk_entry_accessible_parent_class)->finalize (object);
}
static void
-_gtk_entry_accessible_class_init (GtkEntryAccessibleClass *klass)
+gtk_entry_accessible_class_init (GtkEntryAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
}
static void
-_gtk_entry_accessible_init (GtkEntryAccessible *entry)
+gtk_entry_accessible_init (GtkEntryAccessible *entry)
{
entry->priv = G_TYPE_INSTANCE_GET_PRIVATE (entry,
GTK_TYPE_ENTRY_ACCESSIBLE,
G_BEGIN_DECLS
-#define GTK_TYPE_ENTRY_ACCESSIBLE (_gtk_entry_accessible_get_type ())
+#define GTK_TYPE_ENTRY_ACCESSIBLE (gtk_entry_accessible_get_type ())
#define GTK_ENTRY_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ENTRY_ACCESSIBLE, GtkEntryAccessible))
#define GTK_ENTRY_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ENTRY_ACCESSIBLE, GtkEntryAccessibleClass))
#define GTK_IS_ENTRY_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ENTRY_ACCESSIBLE))
GtkWidgetAccessibleClass parent_class;
};
-GType _gtk_entry_accessible_get_type (void);
+GType gtk_entry_accessible_get_type (void);
G_END_DECLS
static void atk_action_interface_init (AtkActionIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkExpanderAccessible, _gtk_expander_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkExpanderAccessible, gtk_expander_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION, atk_action_interface_init))
static const gchar *
if (widget == NULL)
return NULL;
- name = ATK_OBJECT_CLASS (_gtk_expander_accessible_parent_class)->get_name (obj);
+ name = ATK_OBJECT_CLASS (gtk_expander_accessible_parent_class)->get_name (obj);
if (name != NULL)
return name;
gtk_expander_accessible_initialize (AtkObject *obj,
gpointer data)
{
- ATK_OBJECT_CLASS (_gtk_expander_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (gtk_expander_accessible_parent_class)->initialize (obj, data);
obj->role = ATK_ROLE_TOGGLE_BUTTON;
}
g_signal_emit_by_name (atk_obj, "visible-data-changed");
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_expander_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (gtk_expander_accessible_parent_class)->notify_gtk (obj, pspec);
}
static AtkStateSet *
if (widget == NULL)
return NULL;
- state_set = ATK_OBJECT_CLASS (_gtk_expander_accessible_parent_class)->ref_state_set (obj);
+ state_set = ATK_OBJECT_CLASS (gtk_expander_accessible_parent_class)->ref_state_set (obj);
expander = GTK_EXPANDER (widget);
}
static void
-_gtk_expander_accessible_class_init (GtkExpanderAccessibleClass *klass)
+gtk_expander_accessible_class_init (GtkExpanderAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
}
static void
-_gtk_expander_accessible_init (GtkExpanderAccessible *expander)
+gtk_expander_accessible_init (GtkExpanderAccessible *expander)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_EXPANDER_ACCESSIBLE (_gtk_expander_accessible_get_type ())
+#define GTK_TYPE_EXPANDER_ACCESSIBLE (gtk_expander_accessible_get_type ())
#define GTK_EXPANDER_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_EXPANDER_ACCESSIBLE, GtkExpanderAccessible))
#define GTK_EXPANDER_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_EXPANDER_ACCESSIBLE, GtkExpanderAccessibleClass))
#define GTK_IS_EXPANDER_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_EXPANDER_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType _gtk_expander_accessible_get_type (void);
+GType gtk_expander_accessible_get_type (void);
G_END_DECLS
#include "gtkframeaccessible.h"
-G_DEFINE_TYPE (GtkFrameAccessible, _gtk_frame_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE)
+G_DEFINE_TYPE (GtkFrameAccessible, gtk_frame_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE)
static void
gtk_frame_accessible_initialize (AtkObject *accessible,
gpointer data)
{
- ATK_OBJECT_CLASS (_gtk_frame_accessible_parent_class)->initialize (accessible, data);
+ ATK_OBJECT_CLASS (gtk_frame_accessible_parent_class)->initialize (accessible, data);
accessible->role = ATK_ROLE_PANEL;
}
if (widget == NULL)
return NULL;
- name = ATK_OBJECT_CLASS (_gtk_frame_accessible_parent_class)->get_name (obj);
+ name = ATK_OBJECT_CLASS (gtk_frame_accessible_parent_class)->get_name (obj);
if (name != NULL)
return name;
}
static void
-_gtk_frame_accessible_class_init (GtkFrameAccessibleClass *klass)
+gtk_frame_accessible_class_init (GtkFrameAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-_gtk_frame_accessible_init (GtkFrameAccessible *frame)
+gtk_frame_accessible_init (GtkFrameAccessible *frame)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_FRAME_ACCESSIBLE (_gtk_frame_accessible_get_type ())
+#define GTK_TYPE_FRAME_ACCESSIBLE (gtk_frame_accessible_get_type ())
#define GTK_FRAME_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FRAME_ACCESSIBLE, GtkFrameAccessible))
#define GTK_FRAME_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FRAME_ACCESSIBLE, GtkFrameAccessibleClass))
#define GTK_IS_FRAME_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FRAME_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType _gtk_frame_accessible_get_type (void);
+GType gtk_frame_accessible_get_type (void);
G_END_DECLS
#include "config.h"
-#include "gtkiconviewaccessible.h"
+#include "gtkiconviewaccessibleprivate.h"
#include <string.h>
}
static void
-gtk_icon_view_item_accessible_finalize (GObject *object)
+_gtk_icon_view_item_accessible_finalize (GObject *object)
{
GtkIconViewItemAccessible *item;
}
static AtkObject*
-gtk_icon_view_item_accessible_get_parent (AtkObject *obj)
+_gtk_icon_view_item_accessible_get_parent (AtkObject *obj)
{
GtkIconViewItemAccessible *item;
}
static gint
-gtk_icon_view_item_accessible_get_index_in_parent (AtkObject *obj)
+_gtk_icon_view_item_accessible_get_index_in_parent (AtkObject *obj)
{
GtkIconViewItemAccessible *item;
}
static AtkStateSet *
-gtk_icon_view_item_accessible_ref_state_set (AtkObject *obj)
+_gtk_icon_view_item_accessible_ref_state_set (AtkObject *obj)
{
GtkIconViewItemAccessible *item;
GtkIconView *icon_view;
gobject_class = (GObjectClass *)klass;
atk_class = (AtkObjectClass *)klass;
- gobject_class->finalize = gtk_icon_view_item_accessible_finalize;
+ gobject_class->finalize = _gtk_icon_view_item_accessible_finalize;
- atk_class->get_index_in_parent = gtk_icon_view_item_accessible_get_index_in_parent;
- atk_class->get_parent = gtk_icon_view_item_accessible_get_parent;
- atk_class->ref_state_set = gtk_icon_view_item_accessible_ref_state_set;
+ atk_class->get_index_in_parent = _gtk_icon_view_item_accessible_get_index_in_parent;
+ atk_class->get_parent = _gtk_icon_view_item_accessible_get_parent;
+ atk_class->ref_state_set = _gtk_icon_view_item_accessible_ref_state_set;
}
static void atk_component_interface_init (AtkComponentIface *iface);
static void atk_selection_interface_init (AtkSelectionIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkIconViewAccessible, _gtk_icon_view_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkIconViewAccessible, gtk_icon_view_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_COMPONENT, atk_component_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_SELECTION, atk_selection_interface_init))
GtkIconViewAccessible *view;
GtkIconView *icon_view;
- if (ATK_OBJECT_CLASS (_gtk_icon_view_accessible_parent_class)->initialize)
- ATK_OBJECT_CLASS (_gtk_icon_view_accessible_parent_class)->initialize (accessible, data);
+ if (ATK_OBJECT_CLASS (gtk_icon_view_accessible_parent_class)->initialize)
+ ATK_OBJECT_CLASS (gtk_icon_view_accessible_parent_class)->initialize (accessible, data);
icon_view = (GtkIconView*)data;
view = (GtkIconViewAccessible*)accessible;
gtk_icon_view_accessible_clear_cache (view);
- G_OBJECT_CLASS (_gtk_icon_view_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gtk_icon_view_accessible_parent_class)->finalize (object);
}
static void
-_gtk_icon_view_accessible_class_init (GtkIconViewAccessibleClass *klass)
+gtk_icon_view_accessible_class_init (GtkIconViewAccessibleClass *klass)
{
GObjectClass *gobject_class;
AtkObjectClass *atk_class;
}
static void
-_gtk_icon_view_accessible_init (GtkIconViewAccessible *accessible)
+gtk_icon_view_accessible_init (GtkIconViewAccessible *accessible)
{
accessible->priv = G_TYPE_INSTANCE_GET_PRIVATE (accessible,
GTK_TYPE_ICON_VIEW_ACCESSIBLE,
G_BEGIN_DECLS
-#define GTK_TYPE_ICON_VIEW_ACCESSIBLE (_gtk_icon_view_accessible_get_type ())
+#define GTK_TYPE_ICON_VIEW_ACCESSIBLE (gtk_icon_view_accessible_get_type ())
#define GTK_ICON_VIEW_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ICON_VIEW_ACCESSIBLE, GtkIconViewAccessible))
#define GTK_ICON_VIEW_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ICON_VIEW_ACCESSIBLE, GtkIconViewAccessibleClass))
#define GTK_IS_ICON_VIEW_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ICON_VIEW_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType _gtk_icon_view_accessible_get_type (void);
-
-void _gtk_icon_view_accessible_adjustment_changed (GtkIconView *icon_view);
+GType gtk_icon_view_accessible_get_type (void);
G_END_DECLS
--- /dev/null
+/* gtkiconview.c
+ * Copyright (C) 2002, 2004 Anders Carlsson <andersca@gnu.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __GTK_ICON_VIEW_ACCESSIBLE_PRIVATE_H__
+#define __GTK_ICON_VIEW_ACCESSIBLE_PRIVATE_H__
+
+#include "gtkiconviewaccessible.h"
+
+G_BEGIN_DECLS
+
+void _gtk_icon_view_accessible_adjustment_changed (GtkIconView *icon_view);
+
+G_END_DECLS
+
+#endif /* __GTK_ICON_VIEW_ACCESSIBLE_PRIVATE_H__ */
static void atk_image_interface_init (AtkImageIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkImageAccessible, _gtk_image_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkImageAccessible, gtk_image_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_IMAGE, atk_image_interface_init))
static void
gtk_image_accessible_initialize (AtkObject *accessible,
gpointer data)
{
- ATK_OBJECT_CLASS (_gtk_image_accessible_parent_class)->initialize (accessible, data);
+ ATK_OBJECT_CLASS (gtk_image_accessible_parent_class)->initialize (accessible, data);
accessible->role = ATK_ROLE_ICON;
}
g_free (aimage->priv->image_description);
g_free (aimage->priv->stock_name);
- G_OBJECT_CLASS (_gtk_image_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gtk_image_accessible_parent_class)->finalize (object);
}
static const gchar *
if (widget == NULL)
return NULL;
- name = ATK_OBJECT_CLASS (_gtk_image_accessible_parent_class)->get_name (accessible);
+ name = ATK_OBJECT_CLASS (gtk_image_accessible_parent_class)->get_name (accessible);
if (name)
return name;
}
static void
-_gtk_image_accessible_class_init (GtkImageAccessibleClass *klass)
+gtk_image_accessible_class_init (GtkImageAccessibleClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-_gtk_image_accessible_init (GtkImageAccessible *image)
+gtk_image_accessible_init (GtkImageAccessible *image)
{
image->priv = G_TYPE_INSTANCE_GET_PRIVATE (image,
GTK_TYPE_IMAGE_ACCESSIBLE,
G_BEGIN_DECLS
-#define GTK_TYPE_IMAGE_ACCESSIBLE (_gtk_image_accessible_get_type ())
+#define GTK_TYPE_IMAGE_ACCESSIBLE (gtk_image_accessible_get_type ())
#define GTK_IMAGE_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_IMAGE_ACCESSIBLE, GtkImageAccessible))
#define GTK_IMAGE_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_IMAGE_ACCESSIBLE, GtkImageAccessibleClass))
#define GTK_IS_IMAGE_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_IMAGE_ACCESSIBLE))
GtkWidgetAccessibleClass parent_class;
};
-GType _gtk_image_accessible_get_type (void);
+GType gtk_image_accessible_get_type (void);
G_END_DECLS
static void atk_image_interface_init (AtkImageIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkImageCellAccessible, _gtk_image_cell_accessible, GTK_TYPE_RENDERER_CELL_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkImageCellAccessible, gtk_image_cell_accessible, GTK_TYPE_RENDERER_CELL_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_IMAGE, atk_image_interface_init))
static void
GtkImageCellAccessible *image_cell = GTK_IMAGE_CELL_ACCESSIBLE (object);
g_free (image_cell->priv->image_description);
- G_OBJECT_CLASS (_gtk_image_cell_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gtk_image_cell_accessible_parent_class)->finalize (object);
}
static void
-_gtk_image_cell_accessible_class_init (GtkImageCellAccessibleClass *klass)
+gtk_image_cell_accessible_class_init (GtkImageCellAccessibleClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
}
static void
-_gtk_image_cell_accessible_init (GtkImageCellAccessible *image_cell)
+gtk_image_cell_accessible_init (GtkImageCellAccessible *image_cell)
{
image_cell->priv = G_TYPE_INSTANCE_GET_PRIVATE (image_cell,
GTK_TYPE_IMAGE_CELL_ACCESSIBLE,
G_BEGIN_DECLS
-#define GTK_TYPE_IMAGE_CELL_ACCESSIBLE (_gtk_image_cell_accessible_get_type ())
+#define GTK_TYPE_IMAGE_CELL_ACCESSIBLE (gtk_image_cell_accessible_get_type ())
#define GTK_IMAGE_CELL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_IMAGE_CELL_ACCESSIBLE, GtkImageCellAccessible))
#define GTK_IMAGE_CELL_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_IMAGE_CELL_ACCESSIBLE, GtkImageCellAccessibleClass))
#define GTK_IS_IMAGE_CELL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_IMAGE_CELL_ACCESSIBLE))
GtkRendererCellAccessibleClass parent_class;
};
-GType _gtk_image_cell_accessible_get_type (void);
+GType gtk_image_cell_accessible_get_type (void);
G_END_DECLS
static void atk_text_interface_init (AtkTextIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkLabelAccessible, _gtk_label_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkLabelAccessible, gtk_label_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_TEXT, atk_text_interface_init))
static void
-_gtk_label_accessible_init (GtkLabelAccessible *label)
+gtk_label_accessible_init (GtkLabelAccessible *label)
{
label->priv = G_TYPE_INSTANCE_GET_PRIVATE (label,
GTK_TYPE_LABEL_ACCESSIBLE,
GtkWidget *widget;
GtkLabelAccessible *accessible;
- ATK_OBJECT_CLASS (_gtk_label_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (gtk_label_accessible_parent_class)->initialize (obj, data);
accessible = GTK_LABEL_ACCESSIBLE (obj);
g_signal_emit_by_name (atk_obj, "text-selection-changed");
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_label_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (gtk_label_accessible_parent_class)->notify_gtk (obj, pspec);
}
static void
g_free (accessible->priv->text);
- G_OBJECT_CLASS (_gtk_label_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gtk_label_accessible_parent_class)->finalize (object);
}
if (widget == NULL)
return NULL;
- state_set = ATK_OBJECT_CLASS (_gtk_label_accessible_parent_class)->ref_state_set (accessible);
+ state_set = ATK_OBJECT_CLASS (gtk_label_accessible_parent_class)->ref_state_set (accessible);
atk_state_set_add_state (state_set, ATK_STATE_MULTI_LINE);
return state_set;
if (widget == NULL)
return NULL;
- relation_set = ATK_OBJECT_CLASS (_gtk_label_accessible_parent_class)->ref_relation_set (obj);
+ relation_set = ATK_OBJECT_CLASS (gtk_label_accessible_parent_class)->ref_relation_set (obj);
if (!atk_relation_set_contains (relation_set, ATK_RELATION_LABEL_FOR))
{
g_return_val_if_fail (GTK_IS_LABEL_ACCESSIBLE (accessible), NULL);
- name = ATK_OBJECT_CLASS (_gtk_label_accessible_parent_class)->get_name (accessible);
+ name = ATK_OBJECT_CLASS (gtk_label_accessible_parent_class)->get_name (accessible);
if (name != NULL)
return name;
else
}
static void
-_gtk_label_accessible_class_init (GtkLabelAccessibleClass *klass)
+gtk_label_accessible_class_init (GtkLabelAccessibleClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
G_BEGIN_DECLS
-#define GTK_TYPE_LABEL_ACCESSIBLE (_gtk_label_accessible_get_type ())
+#define GTK_TYPE_LABEL_ACCESSIBLE (gtk_label_accessible_get_type ())
#define GTK_LABEL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_LABEL_ACCESSIBLE, GtkLabelAccessible))
#define GTK_LABEL_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_LABEL_ACCESSIBLE, GtkLabelAccessibleClass))
#define GTK_IS_LABEL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_LABEL_ACCESSIBLE))
GtkWidgetAccessibleClass parent_class;
};
-GType _gtk_label_accessible_get_type (void);
+GType gtk_label_accessible_get_type (void);
G_END_DECLS
static void atk_hypertext_impl_interface_init (AtkHyperlinkImplIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkLinkButtonAccessible, _gtk_link_button_accessible, GTK_TYPE_BUTTON_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkLinkButtonAccessible, gtk_link_button_accessible, GTK_TYPE_BUTTON_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_HYPERLINK_IMPL, atk_hypertext_impl_interface_init))
static void
-_gtk_link_button_accessible_init (GtkLinkButtonAccessible *button)
+gtk_link_button_accessible_init (GtkLinkButtonAccessible *button)
{
button->priv = G_TYPE_INSTANCE_GET_PRIVATE (button,
GTK_TYPE_LINK_BUTTON_ACCESSIBLE,
if (button->priv->link)
g_object_unref (button->priv->link);
- G_OBJECT_CLASS (_gtk_link_button_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gtk_link_button_accessible_parent_class)->finalize (object);
}
static void
-_gtk_link_button_accessible_class_init (GtkLinkButtonAccessibleClass *klass)
+gtk_link_button_accessible_class_init (GtkLinkButtonAccessibleClass *klass)
{
G_OBJECT_CLASS (klass)->finalize = gtk_link_button_accessible_finalize;
G_BEGIN_DECLS
-#define GTK_TYPE_LINK_BUTTON_ACCESSIBLE (_gtk_link_button_accessible_get_type ())
+#define GTK_TYPE_LINK_BUTTON_ACCESSIBLE (gtk_link_button_accessible_get_type ())
#define GTK_LINK_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_LINK_BUTTON_ACCESSIBLE, GtkLinkButtonAccessible))
#define GTK_LINK_BUTTON_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_LINK_BUTTON_ACCESSIBLE, GtkLinkButtonAccessibleClass))
#define GTK_IS_LINK_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_LINK_BUTTON_ACCESSIBLE))
GtkButtonAccessibleClass parent_class;
};
-GType _gtk_link_button_accessible_get_type (void);
+GType gtk_link_button_accessible_get_type (void);
G_END_DECLS
#include "config.h"
-#include "gtklockbuttonaccessible.h"
+#include "gtklockbuttonaccessibleprivate.h"
#include "gtk/gtklockbuttonprivate.h"
#include "gtk/gtkwidgetprivate.h"
-G_DEFINE_TYPE (GtkLockButtonAccessible, _gtk_lock_button_accessible, GTK_TYPE_BUTTON_ACCESSIBLE)
+G_DEFINE_TYPE (GtkLockButtonAccessible, gtk_lock_button_accessible, GTK_TYPE_BUTTON_ACCESSIBLE)
static const gchar *
gtk_lock_button_accessible_get_name (AtkObject *obj)
}
static void
-_gtk_lock_button_accessible_class_init (GtkLockButtonAccessibleClass *klass)
+gtk_lock_button_accessible_class_init (GtkLockButtonAccessibleClass *klass)
{
AtkObjectClass *atk_object_class = ATK_OBJECT_CLASS (klass);
}
static void
-_gtk_lock_button_accessible_init (GtkLockButtonAccessible *lockbutton)
+gtk_lock_button_accessible_init (GtkLockButtonAccessible *lockbutton)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_LOCK_BUTTON_ACCESSIBLE (_gtk_lock_button_accessible_get_type ())
+#define GTK_TYPE_LOCK_BUTTON_ACCESSIBLE (gtk_lock_button_accessible_get_type ())
#define GTK_LOCK_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_LOCK_BUTTON_ACCESSIBLE, GtkLockButtonAccessible))
#define GTK_LOCK_BUTTON_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_LOCK_BUTTON_ACCESSIBLE, GtkLockButtonAccessibleClass))
#define GTK_IS_LOCK_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_LOCK_BUTTON_ACCESSIBLE))
GtkButtonAccessibleClass parent_class;
};
-GType _gtk_lock_button_accessible_get_type (void);
-
-void _gtk_lock_button_accessible_name_changed (GtkLockButton *lockbutton);
-
+GType gtk_lock_button_accessible_get_type (void);
G_END_DECLS
--- /dev/null
+/* GAIL - The GNOME Accessibility Implementation Library
+ * Copyright 2001 Sun Microsystems Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __GTK_LOCK_BUTTON_ACCESSIBLE_PRIVATE_H__
+#define __GTK_LOCK_BUTTON_ACCESSIBLE_PRIVATE_H__
+
+#include "gtklockbuttonaccessible.h"
+
+G_BEGIN_DECLS
+
+void _gtk_lock_button_accessible_name_changed (GtkLockButton *lockbutton);
+
+G_END_DECLS
+
+#endif /* __GTK_LOCK_BUTTON_ACCESSIBLE_PRIVATE_H__ */
#include "config.h"
#include "gtkmenuaccessible.h"
+#include "gtkwidgetaccessibleprivate.h"
#include <gtk/gtk.h>
-G_DEFINE_TYPE (GtkMenuAccessible, _gtk_menu_accessible, GTK_TYPE_MENU_SHELL_ACCESSIBLE)
+G_DEFINE_TYPE (GtkMenuAccessible, gtk_menu_accessible, GTK_TYPE_MENU_SHELL_ACCESSIBLE)
static void
gtk_menu_accessible_initialize (AtkObject *obj,
gpointer data)
{
- ATK_OBJECT_CLASS (_gtk_menu_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (gtk_menu_accessible_parent_class)->initialize (obj, data);
obj->role = ATK_ROLE_MENU;
if (gtk_menu_get_attach_widget (GTK_MENU (widget)))
return 0;
- return ATK_OBJECT_CLASS (_gtk_menu_accessible_parent_class)->get_index_in_parent (accessible);
+ return ATK_OBJECT_CLASS (gtk_menu_accessible_parent_class)->get_index_in_parent (accessible);
}
static void
-_gtk_menu_accessible_class_init (GtkMenuAccessibleClass *klass)
+gtk_menu_accessible_class_init (GtkMenuAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-_gtk_menu_accessible_init (GtkMenuAccessible *accessible)
+gtk_menu_accessible_init (GtkMenuAccessible *accessible)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_MENU_ACCESSIBLE (_gtk_menu_accessible_get_type ())
+#define GTK_TYPE_MENU_ACCESSIBLE (gtk_menu_accessible_get_type ())
#define GTK_MENU_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MENU_ACCESSIBLE, GtkMenuAccessible))
#define GTK_MENU_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MENU_ACCESSIBLE, GtkMenuAccessibleClass))
#define GTK_IS_MENU_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MENU_ACCESSIBLE))
GtkMenuShellAccessibleClass parent_class;
};
-GType _gtk_menu_accessible_get_type (void);
+GType gtk_menu_accessible_get_type (void);
G_END_DECLS
#include <string.h>
#include <gtk/gtk.h>
#include "gtkmenuitemaccessible.h"
+#include "gtkwidgetaccessibleprivate.h"
#include "gtk/gtkmenuitemprivate.h"
struct _GtkMenuItemAccessiblePrivate
static void atk_action_interface_init (AtkActionIface *iface);
static void atk_selection_interface_init (AtkSelectionIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkMenuItemAccessible, _gtk_menu_item_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkMenuItemAccessible, gtk_menu_item_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION, atk_action_interface_init);
G_IMPLEMENT_INTERFACE (ATK_TYPE_SELECTION, atk_selection_interface_init))
GtkWidget *parent;
GtkWidget *menu;
- ATK_OBJECT_CLASS (_gtk_menu_item_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (gtk_menu_item_accessible_parent_class)->initialize (obj, data);
g_signal_connect (data, "select", G_CALLBACK (menu_item_select), NULL);
g_signal_connect (data, "deselect", G_CALLBACK (menu_item_deselect), NULL);
AtkObject *menu_item;
AtkStateSet *state_set, *parent_state_set;
- state_set = ATK_OBJECT_CLASS (_gtk_menu_item_accessible_parent_class)->ref_state_set (obj);
+ state_set = ATK_OBJECT_CLASS (gtk_menu_item_accessible_parent_class)->ref_state_set (obj);
atk_state_set_add_state (state_set, ATK_STATE_SELECTABLE);
if (GTK_MENU_ITEM_ACCESSIBLE (obj)->priv->selected)
gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget)))
return ATK_ROLE_MENU;
- return ATK_OBJECT_CLASS (_gtk_menu_item_accessible_parent_class)->get_role (obj);
+ return ATK_OBJECT_CLASS (gtk_menu_item_accessible_parent_class)->get_role (obj);
}
static const gchar *
if (widget == NULL)
return NULL;
- name = ATK_OBJECT_CLASS (_gtk_menu_item_accessible_parent_class)->get_name (obj);
+ name = ATK_OBJECT_CLASS (gtk_menu_item_accessible_parent_class)->get_name (obj);
if (name)
return name;
g_free (accessible->priv->text);
- G_OBJECT_CLASS (_gtk_menu_item_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gtk_menu_item_accessible_parent_class)->finalize (object);
}
static void
g_signal_emit_by_name (atk_obj, "visible-data-changed");
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_menu_item_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (gtk_menu_item_accessible_parent_class)->notify_gtk (obj, pspec);
}
static void
-_gtk_menu_item_accessible_class_init (GtkMenuItemAccessibleClass *klass)
+gtk_menu_item_accessible_class_init (GtkMenuItemAccessibleClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-_gtk_menu_item_accessible_init (GtkMenuItemAccessible *menu_item)
+gtk_menu_item_accessible_init (GtkMenuItemAccessible *menu_item)
{
menu_item->priv = G_TYPE_INSTANCE_GET_PRIVATE (menu_item,
GTK_TYPE_MENU_ITEM_ACCESSIBLE,
parent_widget = gtk_menu_get_attach_widget (GTK_MENU (container));
if (GTK_IS_MENU_ITEM (parent_widget))
{
- GTK_CONTAINER_ACCESSIBLE_CLASS (_gtk_menu_item_accessible_parent_class)->add_gtk (container, widget, gtk_widget_get_accessible (parent_widget));
+ GTK_CONTAINER_ACCESSIBLE_CLASS (gtk_menu_item_accessible_parent_class)->add_gtk (container, widget, gtk_widget_get_accessible (parent_widget));
}
return 1;
parent_widget = gtk_menu_get_attach_widget (GTK_MENU (container));
if (GTK_IS_MENU_ITEM (parent_widget))
{
- GTK_CONTAINER_ACCESSIBLE_CLASS (_gtk_menu_item_accessible_parent_class)->remove_gtk (container, widget, gtk_widget_get_accessible (parent_widget));
+ GTK_CONTAINER_ACCESSIBLE_CLASS (gtk_menu_item_accessible_parent_class)->remove_gtk (container, widget, gtk_widget_get_accessible (parent_widget));
}
return 1;
}
G_BEGIN_DECLS
-#define GTK_TYPE_MENU_ITEM_ACCESSIBLE (_gtk_menu_item_accessible_get_type ())
+#define GTK_TYPE_MENU_ITEM_ACCESSIBLE (gtk_menu_item_accessible_get_type ())
#define GTK_MENU_ITEM_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MENU_ITEM_ACCESSIBLE, GtkMenuItemAccessible))
#define GTK_MENU_ITEM_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MENU_ITEM_ACCESSIBLE, GtkMenuItemAccessibleClass))
#define GTK_IS_MENU_ITEM_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MENU_ITEM_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType _gtk_menu_item_accessible_get_type (void);
+GType gtk_menu_item_accessible_get_type (void);
G_END_DECLS
static void atk_selection_interface_init (AtkSelectionIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkMenuShellAccessible, _gtk_menu_shell_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkMenuShellAccessible, gtk_menu_shell_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_SELECTION, atk_selection_interface_init))
static void
gtk_menu_shell_accessible_initialize (AtkObject *accessible,
gpointer data)
{
- ATK_OBJECT_CLASS (_gtk_menu_shell_accessible_parent_class)->initialize (accessible, data);
+ ATK_OBJECT_CLASS (gtk_menu_shell_accessible_parent_class)->initialize (accessible, data);
accessible->role = ATK_ROLE_UNKNOWN;
}
static void
-_gtk_menu_shell_accessible_class_init (GtkMenuShellAccessibleClass *klass)
+gtk_menu_shell_accessible_class_init (GtkMenuShellAccessibleClass *klass)
{
AtkObjectClass *atk_object_class = ATK_OBJECT_CLASS (klass);
}
static void
-_gtk_menu_shell_accessible_init (GtkMenuShellAccessible *menu_shell)
+gtk_menu_shell_accessible_init (GtkMenuShellAccessible *menu_shell)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_MENU_SHELL_ACCESSIBLE (_gtk_menu_shell_accessible_get_type ())
+#define GTK_TYPE_MENU_SHELL_ACCESSIBLE (gtk_menu_shell_accessible_get_type ())
#define GTK_MENU_SHELL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MENU_SHELL_ACCESSIBLE, GtkMenuShellAccessible))
#define GTK_MENU_SHELL_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MENU_SHELL_ACCESSIBLE, GtkMenuShellAccessibleClass))
#define GTK_IS_MENU_SHELL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MENU_SHELL_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType _gtk_menu_shell_accessible_get_type (void);
+GType gtk_menu_shell_accessible_get_type (void);
G_END_DECLS
static void atk_selection_interface_init (AtkSelectionIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkNotebookAccessible, _gtk_notebook_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkNotebookAccessible, gtk_notebook_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_SELECTION, atk_selection_interface_init))
static gboolean
{
AtkObject *obj;
- obj = _gtk_notebook_page_accessible_new (accessible, child);
+ obj = gtk_notebook_page_accessible_new (accessible, child);
g_hash_table_insert (accessible->priv->pages, child, obj);
atk_object_set_parent (obj, ATK_OBJECT (accessible));
g_signal_emit_by_name (accessible, "children-changed::add", page_num, obj, NULL);
g_return_if_fail (obj);
g_signal_emit_by_name (accessible, "children-changed::remove",
page_num, obj, NULL);
- _gtk_notebook_page_accessible_invalidate (GTK_NOTEBOOK_PAGE_ACCESSIBLE (obj));
+ gtk_notebook_page_accessible_invalidate (GTK_NOTEBOOK_PAGE_ACCESSIBLE (obj));
g_hash_table_remove (accessible->priv->pages, widget);
}
GtkNotebook *notebook;
gint i;
- ATK_OBJECT_CLASS (_gtk_notebook_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (gtk_notebook_accessible_parent_class)->initialize (obj, data);
accessible = GTK_NOTEBOOK_ACCESSIBLE (obj);
notebook = GTK_NOTEBOOK (data);
if (accessible->priv->idle_focus_id)
g_source_remove (accessible->priv->idle_focus_id);
- G_OBJECT_CLASS (_gtk_notebook_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gtk_notebook_accessible_parent_class)->finalize (object);
}
static AtkObject *
}
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_notebook_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (gtk_notebook_accessible_parent_class)->notify_gtk (obj, pspec);
}
/*
}
static void
-_gtk_notebook_accessible_class_init (GtkNotebookAccessibleClass *klass)
+gtk_notebook_accessible_class_init (GtkNotebookAccessibleClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-_gtk_notebook_accessible_init (GtkNotebookAccessible *notebook)
+gtk_notebook_accessible_init (GtkNotebookAccessible *notebook)
{
notebook->priv = G_TYPE_INSTANCE_GET_PRIVATE (notebook,
GTK_TYPE_NOTEBOOK_ACCESSIBLE,
G_BEGIN_DECLS
-#define GTK_TYPE_NOTEBOOK_ACCESSIBLE (_gtk_notebook_accessible_get_type ())
+#define GTK_TYPE_NOTEBOOK_ACCESSIBLE (gtk_notebook_accessible_get_type ())
#define GTK_NOTEBOOK_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_NOTEBOOK_ACCESSIBLE, GtkNotebookAccessible))
#define GTK_NOTEBOOK_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_NOTEBOOK_ACCESSIBLE, GtkNotebookAccessibleClass))
#define GTK_IS_NOTEBOOK_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_NOTEBOOK_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType _gtk_notebook_accessible_get_type (void);
+GType gtk_notebook_accessible_get_type (void);
G_END_DECLS
static void atk_component_interface_init (AtkComponentIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkNotebookPageAccessible, _gtk_notebook_page_accessible, ATK_TYPE_OBJECT,
+G_DEFINE_TYPE_WITH_CODE (GtkNotebookPageAccessible, gtk_notebook_page_accessible, ATK_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE (ATK_TYPE_COMPONENT, atk_component_interface_init))
GtkWidget *label;
AtkObject *selected;
- state_set = ATK_OBJECT_CLASS (_gtk_notebook_page_accessible_parent_class)->ref_state_set (accessible);
+ state_set = ATK_OBJECT_CLASS (gtk_notebook_page_accessible_parent_class)->ref_state_set (accessible);
atk_state_set_add_state (state_set, ATK_STATE_SELECTABLE);
}
static void
-_gtk_notebook_page_accessible_class_init (GtkNotebookPageAccessibleClass *klass)
+gtk_notebook_page_accessible_class_init (GtkNotebookPageAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-_gtk_notebook_page_accessible_init (GtkNotebookPageAccessible *page)
+gtk_notebook_page_accessible_init (GtkNotebookPageAccessible *page)
{
page->priv = G_TYPE_INSTANCE_GET_PRIVATE (page,
GTK_TYPE_NOTEBOOK_PAGE_ACCESSIBLE,
}
AtkObject *
-_gtk_notebook_page_accessible_new (GtkNotebookAccessible *notebook,
- GtkWidget *child)
+gtk_notebook_page_accessible_new (GtkNotebookAccessible *notebook,
+ GtkWidget *child)
{
GObject *object;
AtkObject *atk_object;
}
void
-_gtk_notebook_page_accessible_invalidate (GtkNotebookPageAccessible *page)
+gtk_notebook_page_accessible_invalidate (GtkNotebookPageAccessible *page)
{
AtkObject *obj = ATK_OBJECT (page);
GtkWidget *notebook;
G_BEGIN_DECLS
-#define GTK_TYPE_NOTEBOOK_PAGE_ACCESSIBLE (_gtk_notebook_page_accessible_get_type ())
+#define GTK_TYPE_NOTEBOOK_PAGE_ACCESSIBLE (gtk_notebook_page_accessible_get_type ())
#define GTK_NOTEBOOK_PAGE_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj),GTK_TYPE_NOTEBOOK_PAGE_ACCESSIBLE, GtkNotebookPageAccessible))
#define GTK_NOTEBOOK_PAGE_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_NOTEBOOK_PAGE_ACCESSIBLE, GtkNotebookPageAccessibleClass))
#define GTK_IS_NOTEBOOK_PAGE_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_NOTEBOOK_PAGE_ACCESSIBLE))
AtkObjectClass parent_class;
};
-GType _gtk_notebook_page_accessible_get_type (void);
+GType gtk_notebook_page_accessible_get_type (void);
-AtkObject *_gtk_notebook_page_accessible_new (GtkNotebookAccessible *notebook,
- GtkWidget *child);
+AtkObject *gtk_notebook_page_accessible_new (GtkNotebookAccessible *notebook,
+ GtkWidget *child);
-void _gtk_notebook_page_accessible_invalidate (GtkNotebookPageAccessible *page);
+void gtk_notebook_page_accessible_invalidate (GtkNotebookPageAccessible *page);
G_END_DECLS
static void atk_value_interface_init (AtkValueIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkPanedAccessible, _gtk_paned_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkPanedAccessible, gtk_paned_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_VALUE, atk_value_interface_init))
static void
gtk_paned_accessible_initialize (AtkObject *obj,
gpointer data)
{
- ATK_OBJECT_CLASS (_gtk_paned_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (gtk_paned_accessible_parent_class)->initialize (obj, data);
g_signal_connect (data, "size-allocate",
G_CALLBACK (gtk_paned_accessible_size_allocate_gtk), NULL);
}
static void
-_gtk_paned_accessible_class_init (GtkPanedAccessibleClass *klass)
+gtk_paned_accessible_class_init (GtkPanedAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-_gtk_paned_accessible_init (GtkPanedAccessible *paned)
+gtk_paned_accessible_init (GtkPanedAccessible *paned)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_PANED_ACCESSIBLE (_gtk_paned_accessible_get_type ())
+#define GTK_TYPE_PANED_ACCESSIBLE (gtk_paned_accessible_get_type ())
#define GTK_PANED_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PANED_ACCESSIBLE, GtkPanedAccessible))
#define GTK_PANED_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PANED_ACCESSIBLE, GtkPanedAccessibleClass))
#define GTK_IS_PANED_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PANED_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType _gtk_paned_accessible_get_type (void);
+GType gtk_paned_accessible_get_type (void);
G_END_DECLS
static void atk_value_interface_init (AtkValueIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkProgressBarAccessible, _gtk_progress_bar_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkProgressBarAccessible, gtk_progress_bar_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_VALUE, atk_value_interface_init))
static void
gtk_progress_bar_accessible_initialize (AtkObject *obj,
gpointer data)
{
- ATK_OBJECT_CLASS (_gtk_progress_bar_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (gtk_progress_bar_accessible_parent_class)->initialize (obj, data);
obj->role = ATK_ROLE_PROGRESS_BAR;
}
if (strcmp (pspec->name, "fraction") == 0)
g_object_notify (G_OBJECT (accessible), "accessible-value");
else
- GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_progress_bar_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (gtk_progress_bar_accessible_parent_class)->notify_gtk (obj, pspec);
}
static void
-_gtk_progress_bar_accessible_class_init (GtkProgressBarAccessibleClass *klass)
+gtk_progress_bar_accessible_class_init (GtkProgressBarAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
}
static void
-_gtk_progress_bar_accessible_init (GtkProgressBarAccessible *bar)
+gtk_progress_bar_accessible_init (GtkProgressBarAccessible *bar)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_PROGRESS_BAR_ACCESSIBLE (_gtk_progress_bar_accessible_get_type ())
+#define GTK_TYPE_PROGRESS_BAR_ACCESSIBLE (gtk_progress_bar_accessible_get_type ())
#define GTK_PROGRESS_BAR_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PROGRESS_BAR_ACCESSIBLE, GtkProgressBarAccessible))
#define GTK_PROGRESS_BAR_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PROGRESS_BAR_ACCESSIBLE, GtkProgressBarAccessibleClass))
#define GTK_IS_PROGRESS_BAR_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PROGRESS_BAR_ACCESSIBLE))
GtkWidgetAccessibleClass parent_class;
};
-GType _gtk_progress_bar_accessible_get_type (void);
+GType gtk_progress_bar_accessible_get_type (void);
G_END_DECLS
};
-G_DEFINE_TYPE (GtkRadioButtonAccessible, _gtk_radio_button_accessible, GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE)
+G_DEFINE_TYPE (GtkRadioButtonAccessible, gtk_radio_button_accessible, GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE)
static void
gtk_radio_button_accessible_initialize (AtkObject *accessible,
gpointer data)
{
- ATK_OBJECT_CLASS (_gtk_radio_button_accessible_parent_class)->initialize (accessible, data);
+ ATK_OBJECT_CLASS (gtk_radio_button_accessible_parent_class)->initialize (accessible, data);
accessible->role = ATK_ROLE_RADIO_BUTTON;
}
radio_button = GTK_RADIO_BUTTON_ACCESSIBLE (obj);
- relation_set = ATK_OBJECT_CLASS (_gtk_radio_button_accessible_parent_class)->ref_relation_set (obj);
+ relation_set = ATK_OBJECT_CLASS (gtk_radio_button_accessible_parent_class)->ref_relation_set (obj);
/* If the radio button'group has changed remove the relation */
list = gtk_radio_button_get_group (GTK_RADIO_BUTTON (widget));
}
static void
-_gtk_radio_button_accessible_class_init (GtkRadioButtonAccessibleClass *klass)
+gtk_radio_button_accessible_class_init (GtkRadioButtonAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-_gtk_radio_button_accessible_init (GtkRadioButtonAccessible *radio_button)
+gtk_radio_button_accessible_init (GtkRadioButtonAccessible *radio_button)
{
radio_button->priv = G_TYPE_INSTANCE_GET_PRIVATE (radio_button,
GTK_TYPE_RADIO_BUTTON_ACCESSIBLE,
G_BEGIN_DECLS
-#define GTK_TYPE_RADIO_BUTTON_ACCESSIBLE (_gtk_radio_button_accessible_get_type ())
+#define GTK_TYPE_RADIO_BUTTON_ACCESSIBLE (gtk_radio_button_accessible_get_type ())
#define GTK_RADIO_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RADIO_BUTTON_ACCESSIBLE, GtkRadioButtonAccessible))
#define GTK_RADIO_BUTTON_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RADIO_BUTTON_ACCESSIBLE, GtkRadioButtonAccessibleClass))
#define GTK_IS_RADIO_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RADIO_BUTTON_ACCESSIBLE))
GtkToggleButtonAccessibleClass parent_class;
};
-GType _gtk_radio_button_accessible_get_type (void);
+GType gtk_radio_button_accessible_get_type (void);
G_END_DECLS
GSList *old_group;
};
-G_DEFINE_TYPE (GtkRadioMenuItemAccessible, _gtk_radio_menu_item_accessible, GTK_TYPE_CHECK_MENU_ITEM_ACCESSIBLE)
+G_DEFINE_TYPE (GtkRadioMenuItemAccessible, gtk_radio_menu_item_accessible, GTK_TYPE_CHECK_MENU_ITEM_ACCESSIBLE)
static AtkRelationSet *
radio_menu_item = GTK_RADIO_MENU_ITEM_ACCESSIBLE (obj);
- relation_set = ATK_OBJECT_CLASS (_gtk_radio_menu_item_accessible_parent_class)->ref_relation_set (obj);
+ relation_set = ATK_OBJECT_CLASS (gtk_radio_menu_item_accessible_parent_class)->ref_relation_set (obj);
/* If the radio menu_item's group has changed remove the relation */
list = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (widget));
gtk_radio_menu_item_accessible_initialize (AtkObject *obj,
gpointer data)
{
- ATK_OBJECT_CLASS (_gtk_radio_menu_item_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (gtk_radio_menu_item_accessible_parent_class)->initialize (obj, data);
obj->role = ATK_ROLE_RADIO_MENU_ITEM;
}
static void
-_gtk_radio_menu_item_accessible_class_init (GtkRadioMenuItemAccessibleClass *klass)
+gtk_radio_menu_item_accessible_class_init (GtkRadioMenuItemAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-_gtk_radio_menu_item_accessible_init (GtkRadioMenuItemAccessible *radio_menu_item)
+gtk_radio_menu_item_accessible_init (GtkRadioMenuItemAccessible *radio_menu_item)
{
radio_menu_item->priv = G_TYPE_INSTANCE_GET_PRIVATE (radio_menu_item,
GTK_TYPE_RADIO_MENU_ITEM_ACCESSIBLE,
G_BEGIN_DECLS
-#define GTK_TYPE_RADIO_MENU_ITEM_ACCESSIBLE (_gtk_radio_menu_item_accessible_get_type ())
+#define GTK_TYPE_RADIO_MENU_ITEM_ACCESSIBLE (gtk_radio_menu_item_accessible_get_type ())
#define GTK_RADIO_MENU_ITEM_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RADIO_MENU_ITEM_ACCESSIBLE, GtkRadioMenuItemAccessible))
#define GTK_RADIO_MENU_ITEM_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RADIO_MENU_ITEM_ACCESSIBLE, GtkRadioMenuItemAccessibleClass))
#define GTK_IS_RADIO_MENU_ITEM_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RADIO_MENU_ITEM_ACCESSIBLE))
GtkCheckMenuItemAccessibleClass parent_class;
};
-GType _gtk_radio_menu_item_accessible_get_type (void);
+GType gtk_radio_menu_item_accessible_get_type (void);
G_END_DECLS
static void atk_action_interface_init (AtkActionIface *iface);
static void atk_value_interface_init (AtkValueIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkRangeAccessible, _gtk_range_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkRangeAccessible, gtk_range_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION, atk_action_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_VALUE, atk_value_interface_init))
GtkAdjustment *adj;
GtkRange *gtk_range;
- ATK_OBJECT_CLASS (_gtk_range_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (gtk_range_accessible_parent_class)->initialize (obj, data);
gtk_range = GTK_RANGE (data);
/*
range);
}
- G_OBJECT_CLASS (_gtk_range_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gtk_range_accessible_parent_class)->finalize (object);
}
static void
range);
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_range_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (gtk_range_accessible_parent_class)->notify_gtk (obj, pspec);
}
static void
-_gtk_range_accessible_class_init (GtkRangeAccessibleClass *klass)
+gtk_range_accessible_class_init (GtkRangeAccessibleClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-_gtk_range_accessible_init (GtkRangeAccessible *range)
+gtk_range_accessible_init (GtkRangeAccessible *range)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_RANGE_ACCESSIBLE (_gtk_range_accessible_get_type ())
+#define GTK_TYPE_RANGE_ACCESSIBLE (gtk_range_accessible_get_type ())
#define GTK_RANGE_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RANGE_ACCESSIBLE, GtkRangeAccessible))
#define GTK_RANGE_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RANGE_ACCESSIBLE, GtkRangeAccessibleClass))
#define GTK_IS_RANGE_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RANGE_ACCESSIBLE))
GtkWidgetAccessibleClass parent_class;
};
-GType _gtk_range_accessible_get_type (void);
+GType gtk_range_accessible_get_type (void);
G_END_DECLS
PROP_RENDERER
};
-G_DEFINE_TYPE (GtkRendererCellAccessible, _gtk_renderer_cell_accessible, GTK_TYPE_CELL_ACCESSIBLE)
+G_DEFINE_TYPE (GtkRendererCellAccessible, gtk_renderer_cell_accessible, GTK_TYPE_CELL_ACCESSIBLE)
static void
gtk_renderer_cell_accessible_set_property (GObject *object,
if (renderer_cell->priv->renderer)
g_object_unref (renderer_cell->priv->renderer);
- G_OBJECT_CLASS (_gtk_renderer_cell_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gtk_renderer_cell_accessible_parent_class)->finalize (object);
}
static void
-_gtk_renderer_cell_accessible_class_init (GtkRendererCellAccessibleClass *klass)
+gtk_renderer_cell_accessible_class_init (GtkRendererCellAccessibleClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
}
static void
-_gtk_renderer_cell_accessible_init (GtkRendererCellAccessible *renderer_cell)
+gtk_renderer_cell_accessible_init (GtkRendererCellAccessible *renderer_cell)
{
renderer_cell->priv = G_TYPE_INSTANCE_GET_PRIVATE (renderer_cell,
GTK_TYPE_RENDERER_CELL_ACCESSIBLE,
}
AtkObject *
-_gtk_renderer_cell_accessible_new (GtkCellRenderer *renderer)
+gtk_renderer_cell_accessible_new (GtkCellRenderer *renderer)
{
AtkObject *object;
G_BEGIN_DECLS
-#define GTK_TYPE_RENDERER_CELL_ACCESSIBLE (_gtk_renderer_cell_accessible_get_type ())
+#define GTK_TYPE_RENDERER_CELL_ACCESSIBLE (gtk_renderer_cell_accessible_get_type ())
#define GTK_RENDERER_CELL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RENDERER_CELL_ACCESSIBLE, GtkRendererCellAccessible))
#define GTK_RENDERER_CELL_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RENDERER_CELL_ACCESSIBLE, GtkRendererCellAccessibleClass))
#define GTK_IS_RENDERER_CELL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RENDERER_CELL_ACCESSIBLE))
GtkCellAccessibleClass parent_class;
};
-GType _gtk_renderer_cell_accessible_get_type (void);
+GType gtk_renderer_cell_accessible_get_type (void);
-AtkObject *_gtk_renderer_cell_accessible_new (GtkCellRenderer * renderer);
+AtkObject *gtk_renderer_cell_accessible_new (GtkCellRenderer * renderer);
G_END_DECLS
#include <gtk/gtk.h>
#include "gtkscaleaccessible.h"
-G_DEFINE_TYPE (GtkScaleAccessible, _gtk_scale_accessible, GTK_TYPE_RANGE_ACCESSIBLE)
+G_DEFINE_TYPE (GtkScaleAccessible, gtk_scale_accessible, GTK_TYPE_RANGE_ACCESSIBLE)
static const gchar *
gtk_scale_accessible_get_description (AtkObject *object)
if (layout)
return pango_layout_get_text (layout);
- return ATK_OBJECT_CLASS (_gtk_scale_accessible_parent_class)->get_description (object);
+ return ATK_OBJECT_CLASS (gtk_scale_accessible_parent_class)->get_description (object);
}
static void
-_gtk_scale_accessible_class_init (GtkScaleAccessibleClass *klass)
+gtk_scale_accessible_class_init (GtkScaleAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-_gtk_scale_accessible_init (GtkScaleAccessible *scale)
+gtk_scale_accessible_init (GtkScaleAccessible *scale)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_SCALE_ACCESSIBLE (_gtk_scale_accessible_get_type ())
+#define GTK_TYPE_SCALE_ACCESSIBLE (gtk_scale_accessible_get_type ())
#define GTK_SCALE_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCALE_ACCESSIBLE, GtkScaleAccessible))
#define GTK_SCALE_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCALE_ACCESSIBLE, GtkScaleAccessibleClass))
#define GTK_IS_SCALE_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCALE_ACCESSIBLE))
GtkRangeAccessibleClass parent_class;
};
-GType _gtk_scale_accessible_get_type (void);
+GType gtk_scale_accessible_get_type (void);
G_END_DECLS
static void atk_action_interface_init (AtkActionIface *iface);
static void atk_value_interface_init (AtkValueIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkScaleButtonAccessible, _gtk_scale_button_accessible, GTK_TYPE_BUTTON_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkScaleButtonAccessible, gtk_scale_button_accessible, GTK_TYPE_BUTTON_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION, atk_action_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_VALUE, atk_value_interface_init));
{
GtkAdjustment *adjustment;
- ATK_OBJECT_CLASS (_gtk_scale_button_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (gtk_scale_button_accessible_parent_class)->initialize (obj, data);
adjustment = gtk_scale_button_get_adjustment (GTK_SCALE_BUTTON (data));
if (adjustment)
}
else
{
- GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_scale_button_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (gtk_scale_button_accessible_parent_class)->notify_gtk (obj, pspec);
}
}
static void
-_gtk_scale_button_accessible_class_init (GtkScaleButtonAccessibleClass *klass)
+gtk_scale_button_accessible_class_init (GtkScaleButtonAccessibleClass *klass)
{
AtkObjectClass *atk_object_class = ATK_OBJECT_CLASS (klass);
GtkWidgetAccessibleClass *widget_class = GTK_WIDGET_ACCESSIBLE_CLASS (klass);
}
static void
-_gtk_scale_button_accessible_init (GtkScaleButtonAccessible *button)
+gtk_scale_button_accessible_init (GtkScaleButtonAccessible *button)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_SCALE_BUTTON_ACCESSIBLE (_gtk_scale_button_accessible_get_type ())
+#define GTK_TYPE_SCALE_BUTTON_ACCESSIBLE (gtk_scale_button_accessible_get_type ())
#define GTK_SCALE_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCALE_BUTTON_ACCESSIBLE, GtkScaleButtonAccessible))
#define GTK_SCALE_BUTTON_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCALE_BUTTON_ACCESSIBLE, GtkScaleButtonAccessibleClass))
#define GTK_IS_SCALE_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCALE_BUTTON_ACCESSIBLE))
GtkButtonAccessibleClass parent_class;
};
-GType _gtk_scale_button_accessible_get_type (void);
+GType gtk_scale_button_accessible_get_type (void);
G_END_DECLS
#include "gtkscrollbaraccessible.h"
-G_DEFINE_TYPE (GtkScrollbarAccessible, _gtk_scrollbar_accessible, GTK_TYPE_RANGE_ACCESSIBLE)
+G_DEFINE_TYPE (GtkScrollbarAccessible, gtk_scrollbar_accessible, GTK_TYPE_RANGE_ACCESSIBLE)
static void
-_gtk_scrollbar_accessible_init (GtkScrollbarAccessible *accessible)
+gtk_scrollbar_accessible_init (GtkScrollbarAccessible *accessible)
{
}
gtk_scrollbar_accessible_initialize (AtkObject *accessible,
gpointer data)
{
- ATK_OBJECT_CLASS (_gtk_scrollbar_accessible_parent_class)->initialize (accessible, data);
+ ATK_OBJECT_CLASS (gtk_scrollbar_accessible_parent_class)->initialize (accessible, data);
accessible->role = ATK_ROLE_SCROLL_BAR;
}
parent = gtk_widget_get_parent (widget);
if (!GTK_IS_SCROLLED_WINDOW (parent))
- return ATK_OBJECT_CLASS (_gtk_scrollbar_accessible_parent_class)->get_index_in_parent (accessible);
+ return ATK_OBJECT_CLASS (gtk_scrollbar_accessible_parent_class)->get_index_in_parent (accessible);
scrolled_window = GTK_SCROLLED_WINDOW (parent);
id = 0;
}
static void
-_gtk_scrollbar_accessible_class_init (GtkScrollbarAccessibleClass *klass)
+gtk_scrollbar_accessible_class_init (GtkScrollbarAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
G_BEGIN_DECLS
-#define GTK_TYPE_SCROLLBAR_ACCESSIBLE (_gtk_scrollbar_accessible_get_type ())
+#define GTK_TYPE_SCROLLBAR_ACCESSIBLE (gtk_scrollbar_accessible_get_type ())
#define GTK_SCROLLBAR_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCROLLBAR_ACCESSIBLE, GtkScrollbarAccessible))
#define GTK_SCROLLBAR_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCROLLBAR_ACCESSIBLE, GtkScrollbarAccessibleClass))
#define GTK_IS_SCROLLBAR_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCROLLBAR_ACCESSIBLE))
GtkRangeAccessibleClass parent_class;
};
-GType _gtk_scrollbar_accessible_get_type (void);
+GType gtk_scrollbar_accessible_get_type (void);
G_END_DECLS
#include "gtkscrolledwindowaccessible.h"
-G_DEFINE_TYPE (GtkScrolledWindowAccessible, _gtk_scrolled_window_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE)
+G_DEFINE_TYPE (GtkScrolledWindowAccessible, gtk_scrolled_window_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE)
static void
visibility_changed (GObject *object,
{
GtkScrolledWindow *window;
- ATK_OBJECT_CLASS (_gtk_scrolled_window_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (gtk_scrolled_window_accessible_parent_class)->initialize (obj, data);
window = GTK_SCROLLED_WINDOW (data);
}
static void
-_gtk_scrolled_window_accessible_class_init (GtkScrolledWindowAccessibleClass *klass)
+gtk_scrolled_window_accessible_class_init (GtkScrolledWindowAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-_gtk_scrolled_window_accessible_init (GtkScrolledWindowAccessible *window)
+gtk_scrolled_window_accessible_init (GtkScrolledWindowAccessible *window)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE (_gtk_scrolled_window_accessible_get_type ())
+#define GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE (gtk_scrolled_window_accessible_get_type ())
#define GTK_SCROLLED_WINDOW_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE, GtkScrolledWindowAccessible))
#define GTK_SCROLLED_WINDOW_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE, GtkScrolledWindowAccessibleClass))
#define GTK_IS_SCROLLED_WINDOW_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType _gtk_scrolled_window_accessible_get_type (void);
+GType gtk_scrolled_window_accessible_get_type (void);
G_END_DECLS
static void atk_value_interface_init (AtkValueIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkSpinButtonAccessible, _gtk_spin_button_accessible, GTK_TYPE_ENTRY_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkSpinButtonAccessible, gtk_spin_button_accessible, GTK_TYPE_ENTRY_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_VALUE, atk_value_interface_init))
static void
{
GtkAdjustment *adjustment;
- ATK_OBJECT_CLASS (_gtk_spin_button_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (gtk_spin_button_accessible_parent_class)->initialize (obj, data);
adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (data));
if (adjustment)
spin_button);
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_spin_button_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (gtk_spin_button_accessible_parent_class)->notify_gtk (obj, pspec);
}
static void
-_gtk_spin_button_accessible_class_init (GtkSpinButtonAccessibleClass *klass)
+gtk_spin_button_accessible_class_init (GtkSpinButtonAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
}
static void
-_gtk_spin_button_accessible_init (GtkSpinButtonAccessible *button)
+gtk_spin_button_accessible_init (GtkSpinButtonAccessible *button)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_SPIN_BUTTON_ACCESSIBLE (_gtk_spin_button_accessible_get_type ())
+#define GTK_TYPE_SPIN_BUTTON_ACCESSIBLE (gtk_spin_button_accessible_get_type ())
#define GTK_SPIN_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SPIN_BUTTON_ACCESSIBLE, GtkSpinButtonAccessible))
#define GTK_SPIN_BUTTON_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SPIN_BUTTON_ACCESSIBLE, GtkSpinButtonAccessibleClass))
#define GTK_IS_SPIN_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SPIN_BUTTON_ACCESSIBLE))
GtkEntryAccessibleClass parent_class;
};
-GType _gtk_spin_button_accessible_get_type (void);
+GType gtk_spin_button_accessible_get_type (void);
G_END_DECLS
static void atk_image_interface_init (AtkImageIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkSpinnerAccessible, _gtk_spinner_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkSpinnerAccessible, gtk_spinner_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_IMAGE, atk_image_interface_init));
static void
gtk_spinner_accessible_initialize (AtkObject *accessible,
gpointer widget)
{
- ATK_OBJECT_CLASS (_gtk_spinner_accessible_parent_class)->initialize (accessible, widget);
+ ATK_OBJECT_CLASS (gtk_spinner_accessible_parent_class)->initialize (accessible, widget);
atk_object_set_name (accessible, C_("throbbing progress animation widget", "Spinner"));
atk_object_set_description (accessible, _("Provides visual indication of progress"));
}
static void
-_gtk_spinner_accessible_class_init (GtkSpinnerAccessibleClass *klass)
+gtk_spinner_accessible_class_init (GtkSpinnerAccessibleClass *klass)
{
AtkObjectClass *atk_class = ATK_OBJECT_CLASS (klass);
}
static void
-_gtk_spinner_accessible_init (GtkSpinnerAccessible *self)
+gtk_spinner_accessible_init (GtkSpinnerAccessible *self)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_SPINNER_ACCESSIBLE (_gtk_spinner_accessible_get_type ())
+#define GTK_TYPE_SPINNER_ACCESSIBLE (gtk_spinner_accessible_get_type ())
#define GTK_SPINNER_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SPINNER_ACCESSIBLE, GtkSpinnerAccessible))
#define GTK_SPINNER_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SPINNER_ACCESSIBLE, GtkSpinnerAccessibleClass))
#define GTK_IS_SPINNER_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SPINNER_ACCESSIBLE))
GtkWidgetAccessibleClass parent_class;
};
-GType _gtk_spinner_accessible_get_type (void);
+GType gtk_spinner_accessible_get_type (void);
G_END_DECLS
#include "gtkstatusbaraccessible.h"
-G_DEFINE_TYPE (GtkStatusbarAccessible, _gtk_statusbar_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE)
+G_DEFINE_TYPE (GtkStatusbarAccessible, gtk_statusbar_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE)
static void
text_changed (GtkStatusbar *statusbar,
{
GtkWidget *statusbar = data;
- ATK_OBJECT_CLASS (_gtk_statusbar_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (gtk_statusbar_accessible_parent_class)->initialize (obj, data);
g_signal_connect_after (statusbar, "text-pushed",
G_CALLBACK (text_changed), obj);
if (widget == NULL)
return NULL;
- name = ATK_OBJECT_CLASS (_gtk_statusbar_accessible_parent_class)->get_name (obj);
+ name = ATK_OBJECT_CLASS (gtk_statusbar_accessible_parent_class)->get_name (obj);
if (name != NULL)
return name;
}
static void
-_gtk_statusbar_accessible_class_init (GtkStatusbarAccessibleClass *klass)
+gtk_statusbar_accessible_class_init (GtkStatusbarAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
GtkContainerAccessibleClass *container_class = (GtkContainerAccessibleClass*)klass;
}
static void
-_gtk_statusbar_accessible_init (GtkStatusbarAccessible *bar)
+gtk_statusbar_accessible_init (GtkStatusbarAccessible *bar)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_STATUSBAR_ACCESSIBLE (_gtk_statusbar_accessible_get_type ())
+#define GTK_TYPE_STATUSBAR_ACCESSIBLE (gtk_statusbar_accessible_get_type ())
#define GTK_STATUSBAR_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_STATUSBAR_ACCESSIBLE, GtkStatusbarAccessible))
#define GTK_STATUSBAR_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_STATUSBAR_ACCESSIBLE, GtkStatusbarAccessibleClass))
#define GTK_IS_STATUSBAR_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_STATUSBAR_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType _gtk_statusbar_accessible_get_type (void);
+GType gtk_statusbar_accessible_get_type (void);
G_END_DECLS
static void atk_action_interface_init (AtkActionIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkSwitchAccessible, _gtk_switch_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkSwitchAccessible, gtk_switch_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION, atk_action_interface_init))
static AtkStateSet *
AtkStateSet *state_set;
GtkWidget *widget;
- state_set = ATK_OBJECT_CLASS (_gtk_switch_accessible_parent_class)->ref_state_set (accessible);
+ state_set = ATK_OBJECT_CLASS (gtk_switch_accessible_parent_class)->ref_state_set (accessible);
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
if (widget == NULL)
gtk_switch_accessible_initialize (AtkObject *accessible,
gpointer widget)
{
- ATK_OBJECT_CLASS (_gtk_switch_accessible_parent_class)->initialize (accessible, widget);
+ ATK_OBJECT_CLASS (gtk_switch_accessible_parent_class)->initialize (accessible, widget);
atk_object_set_role (accessible, ATK_ROLE_TOGGLE_BUTTON);
atk_object_set_name (accessible, C_("light switch widget", "Switch"));
}
static void
-_gtk_switch_accessible_class_init (GtkSwitchAccessibleClass *klass)
+gtk_switch_accessible_class_init (GtkSwitchAccessibleClass *klass)
{
AtkObjectClass *atk_class = ATK_OBJECT_CLASS (klass);
}
static void
-_gtk_switch_accessible_init (GtkSwitchAccessible *self)
+gtk_switch_accessible_init (GtkSwitchAccessible *self)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_SWITCH_ACCESSIBLE (_gtk_switch_accessible_get_type ())
+#define GTK_TYPE_SWITCH_ACCESSIBLE (gtk_switch_accessible_get_type ())
#define GTK_SWITCH_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SWITCH_ACCESSIBLE, GtkSwitchAccessible))
#define GTK_SWITCH_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SWITCH_ACCESSIBLE, GtkSwitchAccessibleClass))
#define GTK_IS_SWITCH_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SWITCH_ACCESSIBLE))
GtkWidgetAccessibleClass parent_class;
};
-GType _gtk_switch_accessible_get_type (void);
+GType gtk_switch_accessible_get_type (void);
G_END_DECLS
static void atk_text_interface_init (AtkTextIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkTextCellAccessible, _gtk_text_cell_accessible, GTK_TYPE_RENDERER_CELL_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkTextCellAccessible, gtk_text_cell_accessible, GTK_TYPE_RENDERER_CELL_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_TEXT, atk_text_interface_init))
static AtkStateSet *
{
AtkStateSet *state_set;
- state_set = ATK_OBJECT_CLASS (_gtk_text_cell_accessible_parent_class)->ref_state_set (accessible);
+ state_set = ATK_OBJECT_CLASS (gtk_text_cell_accessible_parent_class)->ref_state_set (accessible);
atk_state_set_add_state (state_set, ATK_STATE_SINGLE_LINE);
g_free (text_cell->priv->cell_text);
- G_OBJECT_CLASS (_gtk_text_cell_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gtk_text_cell_accessible_parent_class)->finalize (object);
}
static const gchar *
}
static void
-_gtk_text_cell_accessible_class_init (GtkTextCellAccessibleClass *klass)
+gtk_text_cell_accessible_class_init (GtkTextCellAccessibleClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
AtkObjectClass *atk_object_class = ATK_OBJECT_CLASS (klass);
}
static void
-_gtk_text_cell_accessible_init (GtkTextCellAccessible *text_cell)
+gtk_text_cell_accessible_init (GtkTextCellAccessible *text_cell)
{
text_cell->priv = G_TYPE_INSTANCE_GET_PRIVATE (text_cell,
GTK_TYPE_TEXT_CELL_ACCESSIBLE,
parent = atk_object_get_parent (parent);
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (parent));
g_return_if_fail (GTK_IS_CELL_ACCESSIBLE_PARENT (parent));
- _gtk_cell_accessible_parent_get_cell_area (GTK_CELL_ACCESSIBLE_PARENT (parent),
- GTK_CELL_ACCESSIBLE (text),
- &rendered_rect);
+ gtk_cell_accessible_parent_get_cell_area (GTK_CELL_ACCESSIBLE_PARENT (parent),
+ GTK_CELL_ACCESSIBLE (text),
+ &rendered_rect);
gtk_cell_renderer_get_preferred_size (GTK_CELL_RENDERER (gtk_renderer),
widget,
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (parent));
g_return_val_if_fail (GTK_IS_CELL_ACCESSIBLE_PARENT (parent), -1);
- _gtk_cell_accessible_parent_get_cell_area (GTK_CELL_ACCESSIBLE_PARENT (parent),
- GTK_CELL_ACCESSIBLE (text),
- &rendered_rect);
+ gtk_cell_accessible_parent_get_cell_area (GTK_CELL_ACCESSIBLE_PARENT (parent),
+ GTK_CELL_ACCESSIBLE (text),
+ &rendered_rect);
gtk_cell_renderer_get_preferred_size (GTK_CELL_RENDERER (gtk_renderer),
widget,
G_BEGIN_DECLS
-#define GTK_TYPE_TEXT_CELL_ACCESSIBLE (_gtk_text_cell_accessible_get_type ())
+#define GTK_TYPE_TEXT_CELL_ACCESSIBLE (gtk_text_cell_accessible_get_type ())
#define GTK_TEXT_CELL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEXT_CELL_ACCESSIBLE, GtkTextCellAccessible))
#define GTK_TEXT_CELL_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TEXT_CELL_ACCESSIBLE, GtkTextCellAccessibleClass))
#define GTK_IS_TEXT_CELL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TEXT_CELL_ACCESSIBLE))
GtkRendererCellAccessibleClass parent_class;
};
-GType _gtk_text_cell_accessible_get_type (void);
+GType gtk_text_cell_accessible_get_type (void);
G_END_DECLS
#include <glib-object.h>
#include <glib/gstdio.h>
#include <gtk/gtk.h>
-#include "gtktextviewaccessible.h"
+#include "gtktextviewaccessibleprivate.h"
#include "gtk/gtkwidgetprivate.h"
struct _GtkTextViewAccessiblePrivate
static void atk_text_interface_init (AtkTextIface *iface);
static void atk_streamable_content_interface_init (AtkStreamableContentIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkTextViewAccessible, _gtk_text_view_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkTextViewAccessible, gtk_text_view_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_EDITABLE_TEXT, atk_editable_text_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_TEXT, atk_text_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_STREAMABLE_CONTENT, atk_streamable_content_interface_init))
gtk_text_view_accessible_initialize (AtkObject *obj,
gpointer data)
{
- ATK_OBJECT_CLASS (_gtk_text_view_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (gtk_text_view_accessible_parent_class)->initialize (obj, data);
obj->role = ATK_ROLE_TEXT;
}
atk_object_notify_state_change (atk_obj, ATK_STATE_EDITABLE, editable);
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_text_view_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (gtk_text_view_accessible_parent_class)->notify_gtk (obj, pspec);
}
static AtkStateSet*
if (widget == NULL)
return NULL;
- state_set = ATK_OBJECT_CLASS (_gtk_text_view_accessible_parent_class)->ref_state_set (accessible);
+ state_set = ATK_OBJECT_CLASS (gtk_text_view_accessible_parent_class)->ref_state_set (accessible);
if (gtk_text_view_get_editable (GTK_TEXT_VIEW (widget)))
atk_state_set_add_state (state_set, ATK_STATE_EDITABLE);
}
static void
-_gtk_text_view_accessible_class_init (GtkTextViewAccessibleClass *klass)
+gtk_text_view_accessible_class_init (GtkTextViewAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
GtkAccessibleClass *accessible_class = GTK_ACCESSIBLE_CLASS (klass);
}
static void
-_gtk_text_view_accessible_init (GtkTextViewAccessible *accessible)
+gtk_text_view_accessible_init (GtkTextViewAccessible *accessible)
{
accessible->priv = G_TYPE_INSTANCE_GET_PRIVATE (accessible,
GTK_TYPE_TEXT_VIEW_ACCESSIBLE,
G_BEGIN_DECLS
-#define GTK_TYPE_TEXT_VIEW_ACCESSIBLE (_gtk_text_view_accessible_get_type ())
+#define GTK_TYPE_TEXT_VIEW_ACCESSIBLE (gtk_text_view_accessible_get_type ())
#define GTK_TEXT_VIEW_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEXT_VIEW_ACCESSIBLE, GtkTextViewAccessible))
#define GTK_TEXT_VIEW_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_VIEW_ACCESSIBLE, GtkTextViewAccessibleClass))
#define GTK_IS_TEXT_VIEW_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TEXT_VIEW_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType _gtk_text_view_accessible_get_type (void);
-
-void _gtk_text_view_accessible_set_buffer (GtkTextView *textview,
- GtkTextBuffer *old_buffer);
+GType gtk_text_view_accessible_get_type (void);
G_END_DECLS
--- /dev/null
+/* GAIL - The GNOME Accessibility Implementation Library
+ * Copyright 2001 Sun Microsystems Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __GTK_TEXT_VIEW_ACCESSIBLE_PRIVATE_H__
+#define __GTK_TEXT_VIEW_ACCESSIBLE_PRIVATE_H__
+
+#include "gtktextviewaccessible.h"
+
+G_BEGIN_DECLS
+
+void _gtk_text_view_accessible_set_buffer (GtkTextView *textview,
+ GtkTextBuffer *old_buffer);
+
+G_END_DECLS
+
+#endif /* __GTK_TEXT_VIEW_ACCESSIBLE_PRIVATE_H__ */
#include "gtktogglebuttonaccessible.h"
-G_DEFINE_TYPE (GtkToggleButtonAccessible, _gtk_toggle_button_accessible, GTK_TYPE_BUTTON_ACCESSIBLE)
+G_DEFINE_TYPE (GtkToggleButtonAccessible, gtk_toggle_button_accessible, GTK_TYPE_BUTTON_ACCESSIBLE)
static void
gtk_toggle_button_accessible_toggled (GtkWidget *widget)
gtk_toggle_button_accessible_initialize (AtkObject *obj,
gpointer data)
{
- ATK_OBJECT_CLASS (_gtk_toggle_button_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (gtk_toggle_button_accessible_parent_class)->initialize (obj, data);
g_signal_connect (data, "toggled",
G_CALLBACK (gtk_toggle_button_accessible_toggled), NULL);
atk_object_notify_state_change (atk_obj, ATK_STATE_ENABLED, (sensitive && !inconsistent));
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_toggle_button_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (gtk_toggle_button_accessible_parent_class)->notify_gtk (obj, pspec);
}
static AtkStateSet*
if (widget == NULL)
return NULL;
- state_set = ATK_OBJECT_CLASS (_gtk_toggle_button_accessible_parent_class)->ref_state_set (accessible);
+ state_set = ATK_OBJECT_CLASS (gtk_toggle_button_accessible_parent_class)->ref_state_set (accessible);
toggle_button = GTK_TOGGLE_BUTTON (widget);
if (gtk_toggle_button_get_active (toggle_button))
}
static void
-_gtk_toggle_button_accessible_class_init (GtkToggleButtonAccessibleClass *klass)
+gtk_toggle_button_accessible_class_init (GtkToggleButtonAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
}
static void
-_gtk_toggle_button_accessible_init (GtkToggleButtonAccessible *button)
+gtk_toggle_button_accessible_init (GtkToggleButtonAccessible *button)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE (_gtk_toggle_button_accessible_get_type ())
+#define GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE (gtk_toggle_button_accessible_get_type ())
#define GTK_TOGGLE_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE, GtkToggleButtonAccessible))
#define GTK_TOGGLE_BUTTON_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE, GtkToggleButtonAccessibleClass))
#define GTK_IS_TOGGLE_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE))
GtkButtonAccessibleClass parent_class;
};
-GType _gtk_toggle_button_accessible_get_type (void);
+GType gtk_toggle_button_accessible_get_type (void);
G_END_DECLS
GList *window_list;
};
-G_DEFINE_TYPE (GtkToplevelAccessible, _gtk_toplevel_accessible, ATK_TYPE_OBJECT)
+G_DEFINE_TYPE (GtkToplevelAccessible, gtk_toplevel_accessible, ATK_TYPE_OBJECT)
static void
gtk_toplevel_accessible_initialize (AtkObject *accessible,
gpointer data)
{
- ATK_OBJECT_CLASS (_gtk_toplevel_accessible_parent_class)->initialize (accessible, data);
+ ATK_OBJECT_CLASS (gtk_toplevel_accessible_parent_class)->initialize (accessible, data);
accessible->role = ATK_ROLE_APPLICATION;
accessible->name = g_get_prgname ();
if (toplevel->priv->window_list)
g_list_free (toplevel->priv->window_list);
- G_OBJECT_CLASS (_gtk_toplevel_accessible_parent_class)->finalize (obj);
+ G_OBJECT_CLASS (gtk_toplevel_accessible_parent_class)->finalize (obj);
}
static gint
}
static void
-_gtk_toplevel_accessible_class_init (GtkToplevelAccessibleClass *klass)
+gtk_toplevel_accessible_class_init (GtkToplevelAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS(klass);
GObjectClass *g_object_class = G_OBJECT_CLASS(klass);
}
static void
-_gtk_toplevel_accessible_init (GtkToplevelAccessible *toplevel)
+gtk_toplevel_accessible_init (GtkToplevelAccessible *toplevel)
{
GtkWindow *window;
GtkWidget *widget;
}
GList *
-_gtk_toplevel_accessible_get_children (GtkToplevelAccessible *accessible)
+gtk_toplevel_accessible_get_children (GtkToplevelAccessible *accessible)
{
return accessible->priv->window_list;
}
G_BEGIN_DECLS
-#define GTK_TYPE_TOPLEVEL_ACCESSIBLE (_gtk_toplevel_accessible_get_type ())
+#define GTK_TYPE_TOPLEVEL_ACCESSIBLE (gtk_toplevel_accessible_get_type ())
#define GTK_TOPLEVEL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOPLEVEL_ACCESSIBLE, GtkToplevelAccessible))
#define GTK_TOPLEVEL_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOPLEVEL_ACCESSIBLE, GtkToplevelAccessibleClass))
#define GTK_IS_TOPLEVEL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOPLEVEL_ACCESSIBLE))
AtkObjectClass parent_class;
};
-GType _gtk_toplevel_accessible_get_type (void);
-GList *_gtk_toplevel_accessible_get_children (GtkToplevelAccessible *accessible);
+GType gtk_toplevel_accessible_get_type (void);
+GList *gtk_toplevel_accessible_get_children (GtkToplevelAccessible *accessible);
G_END_DECLS
#include "gtktreeprivate.h"
#include "gtkwidgetprivate.h"
-#include "gtktreeviewaccessible.h"
+#include "gtktreeviewaccessibleprivate.h"
+
#include "gtkrenderercellaccessible.h"
#include "gtkbooleancellaccessible.h"
#include "gtkimagecellaccessible.h"
#include "gtkcontainercellaccessible.h"
#include "gtktextcellaccessible.h"
#include "gtkcellaccessibleparent.h"
+#include "gtkcellaccessibleprivate.h"
struct _GtkTreeViewAccessiblePrivate
{
static void atk_component_interface_init (AtkComponentIface *iface);
static void gtk_cell_accessible_parent_interface_init (GtkCellAccessibleParentIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkTreeViewAccessible, _gtk_tree_view_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkTreeViewAccessible, gtk_tree_view_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_TABLE, atk_table_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_SELECTION, atk_selection_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_COMPONENT, atk_component_interface_init)
GtkTreeModel *tree_model;
GtkWidget *widget;
- ATK_OBJECT_CLASS (_gtk_tree_view_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (gtk_tree_view_accessible_parent_class)->initialize (obj, data);
accessible = GTK_TREE_VIEW_ACCESSIBLE (obj);
if (accessible->priv->cell_infos)
g_hash_table_destroy (accessible->priv->cell_infos);
- G_OBJECT_CLASS (_gtk_tree_view_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gtk_tree_view_accessible_parent_class)->finalize (object);
}
static void
g_object_thaw_notify (G_OBJECT (accessible));
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_tree_view_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (gtk_tree_view_accessible_parent_class)->notify_gtk (obj, pspec);
}
static void
g_hash_table_remove_all (accessible->priv->cell_infos);
- GTK_ACCESSIBLE_CLASS (_gtk_tree_view_accessible_parent_class)->widget_unset (gtkaccessible);
+ GTK_ACCESSIBLE_CLASS (gtk_tree_view_accessible_parent_class)->widget_unset (gtkaccessible);
}
static gint
return visible_columns;
}
+
static gint
gtk_tree_view_accessible_get_n_children (AtkObject *obj)
{
{
GtkCellAccessible *container_cell;
- container = _gtk_container_cell_accessible_new ();
+ container = gtk_container_cell_accessible_new ();
container_cell = GTK_CELL_ACCESSIBLE (container);
- _gtk_cell_accessible_initialise (container_cell, GTK_WIDGET (treeview), ATK_OBJECT (accessible));
+ _gtk_cell_accessible_initialize (container_cell, GTK_WIDGET (treeview), ATK_OBJECT (accessible));
/* The GtkTreeViewAccessibleCellInfo structure for the container will
* be before the ones for the cells so that the first one we find for
{
renderer = GTK_CELL_RENDERER (l->data);
- cell = GTK_CELL_ACCESSIBLE (_gtk_renderer_cell_accessible_new (renderer));
+ cell = GTK_CELL_ACCESSIBLE (gtk_renderer_cell_accessible_new (renderer));
/* Create the GtkTreeViewAccessibleCellInfo for this cell */
if (parent == ATK_OBJECT (accessible))
cell_info_new (accessible, tree, node, column, cell);
- _gtk_cell_accessible_initialise (cell, GTK_WIDGET (treeview), parent);
+ _gtk_cell_accessible_initialize (cell, GTK_WIDGET (treeview), parent);
if (container)
- _gtk_container_cell_accessible_add_child (container, cell);
+ gtk_container_cell_accessible_add_child (container, cell);
}
g_list_free (renderer_list);
if (container)
AtkStateSet *state_set;
GtkWidget *widget;
- state_set = ATK_OBJECT_CLASS (_gtk_tree_view_accessible_parent_class)->ref_state_set (obj);
+ state_set = ATK_OBJECT_CLASS (gtk_tree_view_accessible_parent_class)->ref_state_set (obj);
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
if (widget != NULL)
}
static void
-_gtk_tree_view_accessible_class_init (GtkTreeViewAccessibleClass *klass)
+gtk_tree_view_accessible_class_init (GtkTreeViewAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
}
static void
-_gtk_tree_view_accessible_init (GtkTreeViewAccessible *view)
+gtk_tree_view_accessible_init (GtkTreeViewAccessible *view)
{
view->priv = G_TYPE_INSTANCE_GET_PRIVATE (view,
GTK_TYPE_TREE_VIEW_ACCESSIBLE,
_gtk_cell_accessible_state_changed (cell, 0, GTK_CELL_RENDERER_FOCUSED);
else
cell = create_cell (treeview, accessible, cursor_tree, cursor_node, new_focus);
-
+
g_signal_emit_by_name (accessible, "active-descendant-changed", cell);
}
}
if (state == GTK_CELL_RENDERER_FOCUSED)
{
GtkTreeViewColumn *focus_column;
-
+
focus_column = get_effective_focus_column (treeview, _gtk_tree_view_get_focus_column (treeview));
if (focus_column)
{
GtkCellAccessible *cell;
-
+
cell = peek_cell (accessible, tree, node, focus_column);
if (cell != NULL)
_gtk_cell_accessible_state_changed (cell, 0, state);
else
cell = create_cell (treeview, accessible, tree, node, focus_column);
-
+
g_signal_emit_by_name (accessible, "active-descendant-changed", cell);
}
#define __GTK_TREE_VIEW_ACCESSIBLE_H__
#include "gtkcontaineraccessible.h"
-#include "gtktreeprivate.h"
G_BEGIN_DECLS
-#define GTK_TYPE_TREE_VIEW_ACCESSIBLE (_gtk_tree_view_accessible_get_type ())
+#define GTK_TYPE_TREE_VIEW_ACCESSIBLE (gtk_tree_view_accessible_get_type ())
#define GTK_TREE_VIEW_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_VIEW_ACCESSIBLE, GtkTreeViewAccessible))
#define GTK_TREE_VIEW_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TREE_VIEW_ACCESSIBLE, GtkTreeViewAccessibleClass))
#define GTK_IS_TREE_VIEW_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_VIEW_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType _gtk_tree_view_accessible_get_type (void);
-
-/* called by treeview code */
-void _gtk_tree_view_accessible_reorder (GtkTreeView *treeview);
-void _gtk_tree_view_accessible_add (GtkTreeView *treeview,
- GtkRBTree *tree,
- GtkRBNode *node);
-void _gtk_tree_view_accessible_remove (GtkTreeView *treeview,
- GtkRBTree *tree,
- GtkRBNode *node);
-void _gtk_tree_view_accessible_changed (GtkTreeView *treeview,
- GtkRBTree *tree,
- GtkRBNode *node);
-
-
-void _gtk_tree_view_accessible_add_column (GtkTreeView *treeview,
- GtkTreeViewColumn *column,
- guint id);
-void _gtk_tree_view_accessible_remove_column (GtkTreeView *treeview,
- GtkTreeViewColumn *column,
- guint id);
-void _gtk_tree_view_accessible_reorder_column(GtkTreeView *treeview,
- GtkTreeViewColumn *column);
-void _gtk_tree_view_accessible_toggle_visibility
- (GtkTreeView *treeview,
- GtkTreeViewColumn *column);
-void _gtk_tree_view_accessible_update_focus_column
- (GtkTreeView *treeview,
- GtkTreeViewColumn *old_focus,
- GtkTreeViewColumn *new_focus);
-
-void _gtk_tree_view_accessible_add_state (GtkTreeView *treeview,
- GtkRBTree *tree,
- GtkRBNode *node,
- GtkCellRendererState state);
-void _gtk_tree_view_accessible_remove_state (GtkTreeView *treeview,
- GtkRBTree *tree,
- GtkRBNode *node,
- GtkCellRendererState state);
+GType gtk_tree_view_accessible_get_type (void);
G_END_DECLS
--- /dev/null
+/* GAIL - The GNOME Accessibility Implementation Library
+ * Copyright 2001 Sun Microsystems Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __GTK_TREE_VIEW_ACCESSIBLE_PRIVATE_H__
+#define __GTK_TREE_VIEW_ACCESSIBLE_PRIVATE_H__
+
+#include "gtktreeviewaccessible.h"
+
+G_BEGIN_DECLS
+
+/* called by treeview code */
+void _gtk_tree_view_accessible_reorder (GtkTreeView *treeview);
+void _gtk_tree_view_accessible_add (GtkTreeView *treeview,
+ GtkRBTree *tree,
+ GtkRBNode *node);
+void _gtk_tree_view_accessible_remove (GtkTreeView *treeview,
+ GtkRBTree *tree,
+ GtkRBNode *node);
+void _gtk_tree_view_accessible_changed (GtkTreeView *treeview,
+ GtkRBTree *tree,
+ GtkRBNode *node);
+
+void _gtk_tree_view_accessible_add_column (GtkTreeView *treeview,
+ GtkTreeViewColumn *column,
+ guint id);
+void _gtk_tree_view_accessible_remove_column (GtkTreeView *treeview,
+ GtkTreeViewColumn *column,
+ guint id);
+void _gtk_tree_view_accessible_reorder_column
+ (GtkTreeView *treeview,
+ GtkTreeViewColumn *column);
+void _gtk_tree_view_accessible_toggle_visibility
+ (GtkTreeView *treeview,
+ GtkTreeViewColumn *column);
+void _gtk_tree_view_accessible_update_focus_column
+ (GtkTreeView *treeview,
+ GtkTreeViewColumn *old_focus,
+ GtkTreeViewColumn *new_focus);
+
+void _gtk_tree_view_accessible_add_state (GtkTreeView *treeview,
+ GtkRBTree *tree,
+ GtkRBNode *node,
+ GtkCellRendererState state);
+void _gtk_tree_view_accessible_remove_state (GtkTreeView *treeview,
+ GtkRBTree *tree,
+ GtkRBNode *node,
+ GtkCellRendererState state);
+
+G_END_DECLS
+
+#endif /* __GTK_TREE_VIEW_ACCESSIBLE_PRIVATE_H__ */
#ifdef GDK_WINDOWING_X11
#include <gdk/x11/gdkx.h>
#endif
-#include "gtkwidgetaccessible.h"
+#include "gtkwidgetaccessibleprivate.h"
#include "gtknotebookpageaccessible.h"
struct _GtkWidgetAccessiblePrivate
static void atk_component_interface_init (AtkComponentIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkWidgetAccessible, _gtk_widget_accessible, GTK_TYPE_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkWidgetAccessible, gtk_widget_accessible, GTK_TYPE_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_COMPONENT, atk_component_interface_init))
/* Translate GtkWidget::focus-in/out-event to AtkObject::focus-event */
if (widget == NULL)
return NULL;
- relation_set = ATK_OBJECT_CLASS (_gtk_widget_accessible_parent_class)->ref_relation_set (obj);
+ relation_set = ATK_OBJECT_CLASS (gtk_widget_accessible_parent_class)->ref_relation_set (obj);
if (GTK_IS_BOX (widget))
return relation_set;
GtkWidget *widget;
AtkStateSet *state_set;
- state_set = ATK_OBJECT_CLASS (_gtk_widget_accessible_parent_class)->ref_state_set (accessible);
+ state_set = ATK_OBJECT_CLASS (gtk_widget_accessible_parent_class)->ref_state_set (accessible);
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
if (widget == NULL)
}
static void
-_gtk_widget_accessible_class_init (GtkWidgetAccessibleClass *klass)
+gtk_widget_accessible_class_init (GtkWidgetAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-_gtk_widget_accessible_init (GtkWidgetAccessible *accessible)
+gtk_widget_accessible_init (GtkWidgetAccessible *accessible)
{
accessible->priv = G_TYPE_INSTANCE_GET_PRIVATE (accessible,
GTK_TYPE_WIDGET_ACCESSIBLE,
G_BEGIN_DECLS
-#define GTK_TYPE_WIDGET_ACCESSIBLE (_gtk_widget_accessible_get_type ())
+#define GTK_TYPE_WIDGET_ACCESSIBLE (gtk_widget_accessible_get_type ())
#define GTK_WIDGET_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WIDGET_ACCESSIBLE, GtkWidgetAccessible))
#define GTK_WIDGET_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WIDGET_ACCESSIBLE, GtkWidgetAccessibleClass))
#define GTK_IS_WIDGET_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WIDGET_ACCESSIBLE))
};
-GType _gtk_widget_accessible_get_type (void);
-
-void _gtk_widget_accessible_set_layer (GtkWidgetAccessible *accessible,
- AtkLayer layer);
+GType gtk_widget_accessible_get_type (void);
G_END_DECLS
--- /dev/null
+/* GAIL - The GNOME Accessibility Implementation Library
+ * Copyright 2001 Sun Microsystems Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __GTK_WIDGET_ACCESSIBLE_PRIVATE_H__
+#define __GTK_WIDGET_ACCESSIBLE_PRIVATE_H__
+
+#include "gtkwidgetaccessible.h"
+
+G_BEGIN_DECLS
+
+void _gtk_widget_accessible_set_layer (GtkWidgetAccessible *accessible,
+ AtkLayer layer);
+
+G_END_DECLS
+
+#endif /* __GTK_WIDGET_ACCESSIBLE_PRIVATE_H__ */
#include <gtk/gtk.h>
+#include "gtkwidgetaccessibleprivate.h"
#include "gtkwindowaccessible.h"
#include "gtktoplevelaccessible.h"
static void atk_window_interface_init (AtkWindowIface *iface);
G_DEFINE_TYPE_WITH_CODE (GtkWindowAccessible,
- _gtk_window_accessible,
+ gtk_window_accessible,
GTK_TYPE_CONTAINER_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_COMPONENT,
atk_component_interface_init)
g_signal_emit_by_name (atk_obj, "visible-data-changed");
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_window_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (gtk_window_accessible_parent_class)->notify_gtk (obj, pspec);
}
static gboolean
GtkWidget *widget = GTK_WIDGET (data);
const gchar *name;
- ATK_OBJECT_CLASS (_gtk_window_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (gtk_window_accessible_parent_class)->initialize (obj, data);
g_signal_connect (data, "window-state-event", G_CALLBACK (window_state_event_cb), NULL);
_gtk_widget_accessible_set_layer (GTK_WIDGET_ACCESSIBLE (obj), ATK_LAYER_WINDOW);
if (widget == NULL)
return NULL;
- name = ATK_OBJECT_CLASS (_gtk_window_accessible_parent_class)->get_name (accessible);
+ name = ATK_OBJECT_CLASS (gtk_window_accessible_parent_class)->get_name (accessible);
if (name != NULL)
return name;
if (widget == NULL)
return -1;
- index = ATK_OBJECT_CLASS (_gtk_window_accessible_parent_class)->get_index_in_parent (accessible);
+ index = ATK_OBJECT_CLASS (gtk_window_accessible_parent_class)->get_index_in_parent (accessible);
if (index != -1)
return index;
if (GTK_IS_TOPLEVEL_ACCESSIBLE (atk_obj))
{
GtkToplevelAccessible *toplevel = GTK_TOPLEVEL_ACCESSIBLE (atk_obj);
- index = g_list_index (_gtk_toplevel_accessible_get_children (toplevel), window);
+ index = g_list_index (gtk_toplevel_accessible_get_children (toplevel), window);
}
else
{
if (widget == NULL)
return NULL;
- relation_set = ATK_OBJECT_CLASS (_gtk_window_accessible_parent_class)->ref_relation_set (obj);
+ relation_set = ATK_OBJECT_CLASS (gtk_window_accessible_parent_class)->ref_relation_set (obj);
if (atk_object_get_role (obj) == ATK_ROLE_TOOL_TIP)
{
if (widget == NULL)
return NULL;
- state_set = ATK_OBJECT_CLASS (_gtk_window_accessible_parent_class)->ref_state_set (accessible);
+ state_set = ATK_OBJECT_CLASS (gtk_window_accessible_parent_class)->ref_state_set (accessible);
window = GTK_WINDOW (widget);
}
static void
-_gtk_window_accessible_class_init (GtkWindowAccessibleClass *klass)
+gtk_window_accessible_class_init (GtkWindowAccessibleClass *klass)
{
GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-_gtk_window_accessible_init (GtkWindowAccessible *accessible)
+gtk_window_accessible_init (GtkWindowAccessible *accessible)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_WINDOW_ACCESSIBLE (_gtk_window_accessible_get_type ())
+#define GTK_TYPE_WINDOW_ACCESSIBLE (gtk_window_accessible_get_type ())
#define GTK_WINDOW_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WINDOW_ACCESSIBLE, GtkWindowAccessible))
#define GTK_WINDOW_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WINDOW_ACCESSIBLE, GtkWindowAccessibleClass))
#define GTK_IS_WINDOW_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WINDOW_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType _gtk_window_accessible_get_type (void);
+GType gtk_window_accessible_get_type (void);
G_END_DECLS
gtk_application_window_new
gtk_application_window_set_show_menubar
gtk_application_get_active_window
+gtk_arrow_accessible_get_type
gtk_arrow_get_type
gtk_arrow_new
gtk_arrow_placement_get_type
gtk_binding_set_new
gtk_bin_get_child
gtk_bin_get_type
+gtk_boolean_cell_accessible_get_type
gtk_border_copy
gtk_border_free
gtk_border_get_type
gtk_builder_set_translation_domain
gtk_builder_value_from_string
gtk_builder_value_from_string_type
+gtk_button_accessible_get_type
gtk_button_box_get_child_secondary
gtk_button_box_get_child_non_homogeneous
gtk_button_box_get_layout
gtk_calendar_set_detail_width_chars
gtk_calendar_set_display_options
gtk_calendar_unmark_day
+gtk_cell_accessible_get_type
+gtk_cell_accessible_parent_activate
+gtk_cell_accessible_parent_edit
+gtk_cell_accessible_parent_expand_collapse
+gtk_cell_accessible_parent_get_cell_area
+gtk_cell_accessible_parent_get_cell_extents
+gtk_cell_accessible_parent_get_child_index
+gtk_cell_accessible_parent_get_renderer_state
+gtk_cell_accessible_parent_get_type
+gtk_cell_accessible_parent_grab_focus
gtk_cell_area_activate
gtk_cell_area_activate_cell
gtk_cell_area_add
gtk_check_button_new
gtk_check_button_new_with_label
gtk_check_button_new_with_mnemonic
+gtk_check_menu_item_accessible_get_type
gtk_check_menu_item_get_active
gtk_check_menu_item_get_draw_as_radio
gtk_check_menu_item_get_inconsistent
gtk_color_selection_set_previous_alpha
gtk_color_selection_set_previous_color
gtk_color_selection_set_previous_rgba
+gtk_combo_box_accessible_get_type
gtk_combo_box_get_active
gtk_combo_box_get_active_id
gtk_combo_box_get_active_iter
gtk_combo_box_text_prepend_text
gtk_combo_box_text_remove
gtk_combo_box_text_remove_all
+gtk_container_accessible_get_type
gtk_container_add
gtk_container_add_with_properties
+gtk_container_cell_accessible_add_child
+gtk_container_cell_accessible_get_children
+gtk_container_cell_accessible_get_type
+gtk_container_cell_accessible_new
+gtk_container_cell_accessible_remove_child
gtk_container_check_resize
gtk_container_child_get
gtk_container_child_get_property
gtk_editable_select_region
gtk_editable_set_editable
gtk_editable_set_position
+gtk_entry_accessible_get_type
gtk_entry_buffer_delete_text
gtk_entry_buffer_emit_deleted_text
gtk_entry_buffer_emit_inserted_text
gtk_entry_get_type
gtk_entry_get_visibility
gtk_entry_get_width_chars
+gtk_entry_icon_accessible_get_type
gtk_entry_icon_position_get_type
gtk_entry_im_context_filter_keypress
gtk_entry_layout_index_to_text_index
gtk_event_box_set_above_child
gtk_event_box_set_visible_window
gtk_events_pending
+gtk_expander_accessible_get_type
gtk_expander_get_expanded
gtk_expander_get_label
gtk_expander_get_label_fill
gtk_font_selection_new
gtk_font_selection_set_font_name
gtk_font_selection_set_preview_text
+gtk_frame_accessible_get_type
gtk_frame_get_label
gtk_frame_get_label_align
gtk_frame_get_label_widget
gtk_icon_theme_set_custom_theme
gtk_icon_theme_set_screen
gtk_icon_theme_set_search_path
+gtk_icon_view_accessible_get_type
gtk_icon_view_convert_widget_to_bin_window_coords
gtk_icon_view_create_drag_icon
gtk_icon_view_drop_position_get_type
gtk_icon_view_unset_model_drag_dest
gtk_icon_view_unset_model_drag_source
gtk_identifier_get_type
+gtk_image_accessible_get_type
+gtk_image_cell_accessible_get_type
gtk_image_clear
gtk_image_get_animation
gtk_image_get_gicon
gtk_justification_get_type
gtk_key_snooper_install
gtk_key_snooper_remove
+gtk_label_accessible_get_type
gtk_label_get_angle
gtk_label_get_attributes
gtk_label_get_current_uri
gtk_layout_set_size
gtk_layout_set_vadjustment
gtk_license_get_type
+gtk_link_button_accessible_get_type
gtk_link_button_get_type
gtk_link_button_get_uri
gtk_link_button_get_visited
gtk_list_store_set_value
gtk_list_store_set_valuesv
gtk_list_store_swap
+gtk_lock_button_accessible_get_type
gtk_lock_button_get_type
gtk_lock_button_new
gtk_lock_button_get_permission
gtk_main_iteration_do
gtk_main_level
gtk_main_quit
+gtk_menu_accessible_get_type
gtk_menu_attach
gtk_menu_attach_to_widget
gtk_menu_bar_get_child_pack_direction
gtk_menu_get_tearoff_state
gtk_menu_get_title
gtk_menu_get_type
+gtk_menu_item_accessible_get_type
gtk_menu_item_activate
gtk_menu_item_deselect
gtk_menu_item_get_accel_path
gtk_menu_set_screen
gtk_menu_set_tearoff_state
gtk_menu_set_title
+gtk_menu_shell_accessible_get_type
gtk_menu_shell_activate_item
gtk_menu_shell_append
gtk_menu_shell_bind_model
gtk_mount_operation_set_parent
gtk_mount_operation_set_screen
gtk_movement_step_get_type
+gtk_notebook_accessible_get_type
gtk_notebook_append_page
gtk_notebook_append_page_menu
gtk_notebook_get_action_widget
gtk_notebook_insert_page_menu
gtk_notebook_new
gtk_notebook_next_page
+gtk_notebook_page_accessible_get_type
+gtk_notebook_page_accessible_invalidate
+gtk_notebook_page_accessible_new
gtk_notebook_page_num
gtk_notebook_popup_disable
gtk_notebook_popup_enable
gtk_paint_spinner
gtk_paint_tab
gtk_paint_vline
+gtk_paned_accessible_get_type
gtk_paned_add1
gtk_paned_add2
gtk_paned_get_child1
gtk_print_win32_devnames_from_win32
gtk_print_win32_devnames_to_win32
#endif
+gtk_progress_bar_accessible_get_type
gtk_progress_bar_get_ellipsize
gtk_progress_bar_get_fraction
gtk_progress_bar_get_inverted
gtk_radio_action_new
gtk_radio_action_set_current_value
gtk_radio_action_set_group
+gtk_radio_button_accessible_get_type
gtk_radio_button_get_group
gtk_radio_button_get_type
gtk_radio_button_join_group
gtk_radio_button_new_with_mnemonic
gtk_radio_button_new_with_mnemonic_from_widget
gtk_radio_button_set_group
+gtk_radio_menu_item_accessible_get_type
gtk_radio_menu_item_get_group
gtk_radio_menu_item_get_type
gtk_radio_menu_item_new
gtk_radio_tool_button_new_from_widget
gtk_radio_tool_button_new_with_stock_from_widget
gtk_radio_tool_button_set_group
+gtk_range_accessible_get_type
gtk_range_get_adjustment
gtk_range_get_fill_level
gtk_range_get_flippable
gtk_render_arrow
gtk_render_background
gtk_render_check
+gtk_renderer_cell_accessible_get_type
+gtk_renderer_cell_accessible_new
gtk_render_expander
gtk_render_extension
gtk_render_focus
gtk_resize_mode_get_type
gtk_response_type_get_type
gtk_rgb_to_hsv
+gtk_scale_accessible_get_type
gtk_scale_add_mark
+gtk_scale_button_accessible_get_type
gtk_scale_button_get_adjustment
gtk_scale_button_get_minus_button
gtk_scale_button_get_plus_button
gtk_scrollable_set_hscroll_policy
gtk_scrollable_set_vadjustment
gtk_scrollable_set_vscroll_policy
+gtk_scrollbar_accessible_get_type
gtk_scrollbar_get_type
gtk_scrollbar_new
+gtk_scrolled_window_accessible_get_type
gtk_scrolled_window_add_with_viewport
gtk_scrolled_window_get_hadjustment
gtk_scrolled_window_get_hscrollbar
gtk_socket_new
#endif
gtk_sort_type_get_type
+gtk_spin_button_accessible_get_type
gtk_spin_button_configure
gtk_spin_button_get_adjustment
gtk_spin_button_get_digits
gtk_spin_button_spin
gtk_spin_button_update
gtk_spin_button_update_policy_get_type
+gtk_spinner_accessible_get_type
gtk_spinner_get_type
gtk_spinner_new
gtk_spinner_start
gtk_spin_type_get_type
gtk_state_flags_get_type
gtk_state_type_get_type
+gtk_statusbar_accessible_get_type
gtk_statusbar_get_context_id
gtk_statusbar_get_message_area
gtk_statusbar_get_type
gtk_stock_list_ids
gtk_stock_lookup
gtk_stock_set_translate_func
+gtk_switch_accessible_get_type
gtk_switch_get_active
gtk_switch_get_type
gtk_switch_new
gtk_text_buffer_unregister_deserialize_format
gtk_text_buffer_unregister_serialize_format
gtk_text_byte_begins_utf8_char
+gtk_text_cell_accessible_get_type
gtk_text_child_anchor_get_deleted
gtk_text_child_anchor_get_type
gtk_text_child_anchor_get_widgets
gtk_text_tag_table_new
gtk_text_tag_table_remove
gtk_text_unknown_char_utf8_gtk_tests_only
+gtk_text_view_accessible_get_type
gtk_text_view_add_child_at_anchor
gtk_text_view_add_child_in_window
gtk_text_view_backward_display_line
gtk_toggle_action_set_active
gtk_toggle_action_set_draw_as_radio
gtk_toggle_action_toggled
+gtk_toggle_button_accessible_get_type
gtk_toggle_button_get_active
gtk_toggle_button_get_inconsistent
gtk_toggle_button_get_mode
gtk_tooltip_set_text
gtk_tooltip_set_tip_area
gtk_tooltip_trigger_tooltip_query
+gtk_toplevel_accessible_get_children
+gtk_toplevel_accessible_get_type
#ifdef GDK_WINDOWING_X11
gtk_tray_icon_get_type
#endif
gtk_tree_store_set_value
gtk_tree_store_set_valuesv
gtk_tree_store_swap
+gtk_tree_view_accessible_get_type
gtk_tree_view_append_column
gtk_tree_view_collapse_all
gtk_tree_view_collapse_row
gtk_vscrollbar_new
gtk_vseparator_get_type
gtk_vseparator_new
+gtk_widget_accessible_get_type
gtk_widget_activate
gtk_widget_add_accelerator
gtk_widget_add_device_events
#ifdef GDK_WINDOWING_WIN32
gtk_win32_embed_widget_get_type
#endif
+gtk_window_accessible_get_type
gtk_window_activate_default
gtk_window_activate_focus
gtk_window_activate_key
#include "gtktreednd.h"
#include "gtktypebuiltins.h"
#include "gtkprivate.h"
-#include "a11y/gtkiconviewaccessible.h"
+#include "a11y/gtkiconviewaccessibleprivate.h"
/**
* SECTION:gtkiconview
if (icon_view->priv->doing_rubberband)
gtk_icon_view_update_rubberband (GTK_WIDGET (icon_view));
-
+
_gtk_icon_view_accessible_adjustment_changed (icon_view);
}
}
#include "gtklabel.h"
#include "gtksizegroup.h"
#include "gtkintl.h"
-#include "a11y/gtklockbuttonaccessible.h"
+#include "a11y/gtklockbuttonaccessibleprivate.h"
/**
* SECTION:gtklockbutton
#include "gtkstylecontextprivate.h"
#include "gtkcssstylepropertyprivate.h"
-#include "a11y/gtktextviewaccessible.h"
+#include "a11y/gtktextviewaccessibleprivate.h"
/**
* SECTION:gtktextview
#include "gtkmarshalers.h"
#include "gtkintl.h"
#include "gtktypebuiltins.h"
-#include "a11y/gtktreeviewaccessible.h"
+#include "a11y/gtktreeviewaccessibleprivate.h"
/**
#include "gtkmain.h"
#include "gtksettings.h"
#include "gtkwidgetpath.h"
-#include "a11y/gtktreeviewaccessible.h"
+#include "a11y/gtktreeviewaccessibleprivate.h"
/**
#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtktypebuiltins.h"
-#include "a11y/gtktreeviewaccessible.h"
+#include "a11y/gtktreeviewaccessibleprivate.h"
/**
projects / gtk4.git / commitdiff